Abandon the large volume model! The 510000 lines of code leaked by Anthropic reveal the secret of 100 times efficiency: light shell, heavy skills! Steve Yegge, a Silicon Valley veteran and former top architect at Google and Amazon, recently spoke the truth: Geeks who are proficient in using AI programming agents are now 100 times more productive than ordinary programmers. Many people's first reaction after listening is that the big model has become smarter again. Completely wrong direction. The ordinary person with twice the efficiency and the expert with 100 times the efficiency actually use the same big model. The real barrier is not intelligence at all, but a geek architecture that can be written on an index card. In March of this year, Anthropic accidentally leaked 510000 lines of Claude Code's source code to npm. The exposure of this source code has made the entire Silicon Valley see the underlying logic behind top institutions such as YC quietly making a fortune: the real moat is not about how smart the model is, but about the shell wrapped around it. This set of mental techniques can be summarized as extremely simple: Thin Harness, Fat Skills. Forget about those vague and elusive hints of mysticism, true masters are playing with these five core definitions. 1. The Five Core Definitions of Architects ① Skill file: Using Markdown encapsulated function calls to write the standard problem-solving process in Markdown, which essentially involves writing underlying functions. It defines the process, not the specific task. For example, writing a "survey" skill involves seven steps to define data, establish a timeline, and present positive and negative arguments. Send medical emails to it, it is the medical anti-corruption expert; Send financial statements to it, it's a money laundering tracker. This is simply compiling human judgment directly into underlying code. ② Lightweight Shell: Say goodbye to the bloated API quagmire Shell only does the most basic tasks: running loops, reading and writing files, and preventing crashes. The thinner the better. The dumbest thing to do is to create dozens of giant toolboxes, which run for several seconds every time they are called. Tools must be extremely streamlined, running a small instruction in a few hundred milliseconds is the key. ③ Scheduler: Don't let the context be filled with garbage. The skill is responsible for what to do and the scheduler is responsible for providing what information at what time. Putting all the 20000 lines of troubleshooting guidelines into the system will definitely cause the large model to malfunction due to garbled characters. Cut it down to two hundred lines, all of which become scheduling instructions pointing to specific documents. Once the system perceives the demand, it will automatically retrieve it accurately. The knowledge base can expand infinitely, but it must not pollute the current dialogue window. ④ Draw a clear boundary: latent space vs deterministic execution. This is where countless architects fall into pitfalls. The latent space is used for intellectual labor, summarizing and finding patterns, which is what the model excels at. Deterministic space is used for pure execution, running SQL, doing arithmetic, and the input must correspond to absolutely consistent output. If the big model were to create a seating chart for 800 people, it would definitely be fabricated. The top-level system will delegate all intellectual activities to the skill level and tightly store pure physical activities in the underlying tools. ⑤ Summary: To extract the core value of data, a big model must have the ability to read dozens of conflicting documents and accurately extract a structured conclusion on a single page. This cannot be solved by database search, it requires real reading and judgment. 2. Practical closed-loop: How to perfectly schedule 6000 top-level brains The top incubator YC directly applied this architecture to internal operations. Faced with the backing and matching of 6000 top founders, relying solely on manual labor is fundamentally unsolvable. Who has the brain capacity to hold the code submission records and in-depth interview transcripts of thousands of people? But this architecture runs extremely perfectly. The underlying script of the system automatically checks everyone's GitHub activity, which is purely deterministic physical labor. Then the model cross compares the data with the questionnaire filled out by the founder. If someone boasts about building AI infrastructure, but the code is all about writing the underlying billing module. The model will soon be able to identify the flaws and directly re label it as a fintech. This is the top-level judgment of latent space. 3. The self reproduction of the system What's even more terrifying is its self evolving ability. After each activity, the system will automatically pull feedback questionnaires with average ratings and extract reasons for imperfect matching on its own. Then, it will directly rewrite the underlying rules in the skill file. The next day when it ran the match again, it had already absorbed yesterday's lesson. The entire closed loop does not require manual modification of even a single line of code. In this geek community, there is an iron fisted rule: never be a one-time laborer. If something happens again in the future, never manually do it again. Run the hands-on teaching system several times, confirm it is correct, and directly package it into a skill file. Every skill written down is a permanent system upgrade. When the next generation model is released, these fixed judgments will still be fully effective. This is the only path for ordinary people to achieve a hundredfold increase in productivity.