Garry Tan’s 400x Productivity Secret: A Complete Breakdown of Thin Harness + Fat Skills

I just finished listening to this episode of Light Cone, where Garry Tan laid out exactly how to be a builder in the AI era.

The most striking part was his personal story: he hadn’t really written code for 13 years. As YC’s CEO, his schedule was packed, and he’d long since stepped away from hands-on coding. But over the past few months, using Claude Code and OpenClaw, he fought his way back to the front lines of development — cranking out hundreds of thousands of lines of code and shipping Garry’s List and Gstack.

Garry’s List is an agentic news platform that can automatically research topics and write long-form articles. It’s reportedly crossed 100k+ stars. Gstack is an agent harness he built himself — essentially a system that helps AI agents work more efficiently.

The single most important line from this episode:

You’re not the one writing the code. You’re directing machines to write it.

The old-school builder wrote code themselves. The modern builder is more like a hybrid of director, CEO, product manager, and architect. You bring the vision and taste; the agent handles execution, completion, testing, fixing, and iteration.

13 Years Without Coding — How Did He Suddenly Explode?

Garry Tan co-founded Posterous, which was later acquired by Twitter. He then moved into investing and eventually became YC’s CEO, essentially leaving day-to-day coding behind.

But in early 2025, he suddenly wanted to build something new: Garry’s List.

It’s an agentic platform that automatically researches information, organizes data, and generates long-form content. By the old way of doing things, a project like this would be enormously complex — just setting up the framework, writing crawlers, building RAG, and wiring up workflows would be enough to make your head spin.

Then Garry discovered how good Claude Code was.

His first move wasn’t to start writing code directly. Instead, he took every repetitive action he did regularly and turned it into a Markdown skill.

He transformed tasks like “how to plan,” “how to write code,” “how to review,” “how to test,” and “how to research” into structured playbooks, then handed them to agents to execute.

The results were staggering. A feature that might have taken days before now produced a PR in minutes — complete with tests.

This wasn’t just a productivity boost. It turned someone who hadn’t written code in 13 years back into a high-velocity builder.

Garry’s Core Philosophy: Thin Harness + Fat Skills

The most memorable concept from this episode is what Garry calls:

Thin Harness + Fat Skills

A Thin Harness means keeping the agent execution framework as lean and simple as possible. You don’t need an elaborate system — tools like OpenClaw or Claude Code are enough.

Fat Skills means putting the real complexity into Markdown skill files.

These skills act like recipes, walking the agent through exactly what to do step by step. Things like how to do product planning, how to write an engineering spec, how to do a code review, how to run QA, how to draw data flow diagrams.

Here’s the counterintuitive part:

Don’t try to encode everything in code.

The conventional wisdom has always been that complex logic belongs in code — it’s deterministic, executable, and reusable. But in the agent era, Garry argues that a lot of logic is actually better expressed in Markdown.

Code is deterministic: miss one edge case and you have a bug. Markdown is fuzzy and open-ended, which is exactly what agents are good at understanding and working with.

Garry put it in an interesting way: where writing code used to require careful, exhaustive handling of edge cases, now you can just tell the agent to “boil the ocean” — surface everything imaginable and let it handle the details.

The underlying shift is profound.

Before, humans were the executors and machines were tools. Now, humans are commanders and machines translate fuzzy intent into concrete implementation.

Practical Tip #1: How to Use Claude Code to Get Back Into Coding Fast

Garry’s first step was dead simple: open Claude Code (later switching mostly to OpenClaw), then start converting his repeated workflows into skills.

One of his most important skills is called Plan-Eng-Review.

The flow looks roughly like this:

Have the agent do planning first, then generate ASCII diagrams — data flows, user journeys, state machines — all of it. Then move into code implementation, followed by review and testing.

This is critical.

The biggest problem most people have when using AI to write code is jumping straight to implementation, which quickly causes the agent to go off track. Garry’s method: always draw the diagram before writing a single line. Get the agent to articulate structure, state, and flow clearly before touching the code.

His current daily workflow looks something like this:

Start with a CEO Plan — ask 10x questions like Brian Chesky would: Could this feature be ten times bigger? Is there a more extreme, more user-friendly approach? Are we being held back by legacy software thinking?

Then run Plan-Eng-Review, letting the agent turn the plan into an engineering spec, then into code.

Finally, use Codex for a final code review. Garry is clear about the division of labor: Claude is better for creativity and generation; Codex is better for rigorous review.

On top of that, he uses Playwright combined with a Browse skill for automated QA.

The result: he can ship 10+ PRs a day — and these aren’t throwaway demos, but code with full test coverage and a proper review process.

Practical Tip #2: What Exactly Is Gstack?

Gstack is a custom agent harness Garry built on top of OpenClaw.

It comes loaded with skills like CEO, Designer, DevEx, Plan-Eng-Review, Browse, QA, and more.

The usage is straightforward.

When you want to build a new feature, start with /ceo — the agent automatically does market research, 10x thinking, product judgment, and architecture sketches.

Then use /plan-eng-review to generate complete code and tests.

Finally, run /codex or /claude for a final review.

It sounds like a dev tool, but it’s really more of a workflow that upgrades you from “coder” to “product CEO.”

Garry’s counterintuitive take: Gstack isn’t replacing you — it’s transforming you from “engineer” to “CEO + product manager.”

You no longer need to spend most of your time on boilerplate, repetitive logic, fixing tests, or digging through docs. Your job is to surface requirements, set direction, calibrate taste, and decide what’s worth building.

The agent handles 95% of the work. Humans make the final 5% of judgment calls.

But that 5% is what determines the ceiling of the product.

Practical Tip #3: What Does Tokenmaxxing Actually Mean?

One of Garry’s favorite terms is Tokenmaxxing.

It means: burn tokens to the max.

Most people try to conserve tokens — keep prompts short, minimize costs, compress context. Garry’s philosophy is the exact opposite:

If you can add more context, add it.

In the agent era, tokens aren’t a cost center — they’re a lever. You’re trading tokens for time, attention, and execution.

His specific approach: let the agent “boil the ocean” first.

Before writing any code, feed in everything relevant — related code, documentation, previous PRs, product background, user feedback. Don’t hand it a bare prompt; pack in as much context as you can.

Inside Gstack, he also uses RAG with hybrid search via the Browse skill to pull in data from across the web.

Most importantly, always draw ASCII diagrams before coding. Map out data flows, state machine transitions, and user paths. This keeps the agent from getting lost in a sea of context.

Garry used Garry’s List as an example: the RAG system ingests huge amounts of information from GitHub and the internet, and the articles it produces reportedly rival or surpass many human journalists in quality.

Here’s the provocative conclusion:

The most capable people in the future won’t be the ones who are best at saving tokens — they’ll be the ones who are best at spending them.

Counterintuitive Take #1: Lines of Code Actually Matter

Plenty of people have dunked on Garry online, arguing that lines of code don’t measure productivity.

That argument made sense in the past. When humans write code, line counts are easy to game — more doesn’t mean better.

But Garry’s rebuttal: in the agent era, lines of code is actually a useful metric.

Agents aren’t padding their output to look busy. They’re writing real logic, tests, fixes, and implementations.

After running the numbers, Garry found that his daily effective code output is 400x what it was in 2013.

The point isn’t “more code equals better.”

The real point: agents free you from boilerplate and repetitive work, so you can put your attention on architecture, product, and judgment.

Before, a single person pushing one feature forward per day was solid progress. Now, one person can drive multiple PRs, multiple experiments, and multiple product directions simultaneously.

That’s what 400x actually means.

Counterintuitive Take #2: Agents Don’t Replace Humans — They Amplify Human Agency

A lot of people worry that AI will take programmers’ jobs.

Garry’s view is the opposite.

He thinks this is actually the moment of greatest human power.

In the old model, coding was execution. You’d have an idea for a feature and then spend enormous amounts of time translating it into actual code. Between your idea and a working product sat mountains of manual labor.

Now coding has become direction. As long as you have vision, taste, and the ability to judge what good looks like, agents can absorb the massive execution gap in between.

This is exactly why someone who hadn’t seriously coded for 13 years could become an extraordinarily prolific builder again.

He didn’t go back to 2013-era “write every line yourself.” He stepped into something new:

Humans set the direction. Agents handle execution.

This isn’t humans being replaced by AI. It’s humans being amplified by it.

Where Should Ordinary People Start?

If you want to get back into coding, Garry’s advice is actually pretty simple.

Don’t try to build a massively complex agent system from the start. Install Claude Code or OpenClaw, and begin by writing one simple skill.

Start with a product planning skill, for example — something that makes the agent help you think through users, goals, scope, and risks before tackling any feature.

Then build a consistent workflow:

Use the CEO skill to plan first.

Have the agent draw ASCII diagrams to map out data flows, user journeys, and state machines.

Then have the agent write the code and tests.

Finally, use Codex or another model for code review.

Throughout all of this, the Tokenmaxxing mindset is the most important thing to internalize.

Don’t be stingy with tokens. Feed in as much context as you can. Let the agent read more docs. Let it run more tests. Burning tokens is fundamentally buying time.

And don’t be afraid of the agent making mistakes.

When it does, let it fix itself. You don’t need to personally go in and patch every small detail. Your job is to judge: Is the direction right? Is the experience good? Is the architecture sound? Can this actually ship?

One-Line Summary

Garry Tan has proved something with his own actions:

In the AI era, you don’t need to relearn how to write code line by line. You need to learn how to direct agents.

Tokenmaxxing, Thin Harness, Fat Skills — combine these three things, and you have the formula that gives ordinary people access to 400x productivity.

My biggest takeaway from this episode: we used to worry that AI would replace programmers, but what’s actually happening looks more like AI is upgrading programmers into “super commanders.”

The truly scarce resource was never code. It’s always been human vision and taste.

How often are you using Claude Code, Cursor, or OpenClaw these days? Drop a comment below.

For the full transcript, you can grab it for free on Podwise.