Open-source everything12 minAfter his AI-built Adobe and Office clones went viral, ArtCraft's Brandon Thomas laid out the bigger plan: rebuild the closed software world as open source, in Rust, run by coding agents. Here's how the 24-hour Photoshop happened, what came next, the rules he uses for agents versus humans, and the legal and quality questions he can't wave away.Read now →

AI Has Eaten 'Tactical' Programming. A Former Drama Student Who Teaches Developers Says the Skill That's Left Is Worth More Than Ever
TypeScript educator turned AI-skills author Matt Pocock argues that coding agents are brilliant at today's task and terrible at tomorrow's codebase. His fix: shared language, specs, small context windows, adversarial reviews, 'one-way door' merge checks and a constant retro loop. Here's his complete workflow, the skills behind it and what new developers should learn instead of a programming language.
Ask Matt Pocock whether a teenager who wants to be a software developer should learn a specific programming language, and he answers in one word: "Nah."
That's a striking thing to hear from someone who made his name teaching TypeScript. Pocock built Total TypeScript into one of the best-known courses in web development after wrestling with type safety in XState, a state-machine library. Then AI arrived. He was skeptical, came around, and now his open-source collection of agent "skills," small Markdown files describing processes for coding agents, has become a default part of many developers' AI toolkits. He says the repo is approaching 300,000 GitHub stars.
He also has a drama degree, spent six years as a voice coach, and taught himself to code around 2015.
In a long conversation this week about how to actually code with AI, Pocock laid out a workflow that pushes back on the "just vibe it" era. His thesis: AI is superb at tactical programming and terrible at strategic programming. Learn the strategic part and you go from a 5x agent user to something like a 100x one.
Here's the complete method.
Tactical vs strategic programming
Pocock borrows the distinction from John Ousterhout's A Philosophy of Software Design.
- Tactical programming is the sergeant winning today's battle: make this feature work, fix this bug.
- Strategic programming is the general winning the war: will this change make the codebase easier or harder to work in nine months from now?
Good engineers always blended both. AI models, he argues, are almost purely tactical, and for a structural reason. Benchmarks grade a model on one task at a time. Thinking long-term doesn't raise the score, and strategic mistakes don't surface until months later, so they're nearly impossible to grade.
The result is familiar to anyone who has vibe coded for a few weeks. The agent solves each request, the code quietly gets worse, and since the code is the environment the agent works in, the agent itself gets worse too. Pocock compares it to the meme of the dog sitting calmly in a burning room saying "this is fine."
Someone has to keep the house in order. For now, he says, that's you.
Should every developer use AI? "It's ridiculous not to"
Pocock doesn't romanticize hand-coding. So much of a developer's job used to be tactical, he notes, and now you can pay less than minimum wage for an agent to do it. He's happy to see tactical programming go. The strategic work, improving team velocity and code quality, was always the interesting part anyway.
And it's learnable. Coding has always been easier than outsiders think, and strategic programming is mostly caring a bit more than the person next to you about the quality of what ships. His blunt version: you have to give a damn.
Step 1: Close the communication gap with "grilling"
Most people just prompt the agent and hope. Pocock thinks they underestimate the communication gap. An agent is like a contractor dropped into your project with total amnesia, like the protagonist of Memento. Left alone, it will agreeably bulldoze toward something roughly like what you asked for, sometimes adding features you never requested.
His most famous skill, grill-me, flips the dynamic: the agent interviews you, one question at a time, until you're aligned. His upgraded version, grill-with-docs, adds a second skill for domain modeling.
In a live demo, he gave it a deliberately vague prompt: the teleprompter part of his video editor had gotten cluttered; help clean it up. A sub-agent explored the codebase in the background while the main agent asked: what does the teleprompter read from? What's on screen while you film? What clutter have you noticed? Does the script still auto-scroll?
He says the communication gap won't disappear as models get smarter, because the gap is often on the human side. Even a teacher of 14 years gets complacent and under-specifies.
Step 2: Build a shared language (glossary + ADRs)
This idea comes from Eric Evans' classic Domain-Driven Design: the language you use matters enormously.
Pocock's repos contain a glossary of the application's real concepts. For his course platform that means courses, sections, lessons, course versions, drafts and pending versions. Every skill tells the agent to use that glossary when writing specs and code.
The payoff is huge. He's seen codebases where the front end calls something a "reversal," the email calls it a "pending chargeback" and the database calls it a "refund." That confuses humans and agents alike. With a shared vocabulary, he says, the agent feels like it's inside your brain, and it even makes wordy models more concise because they speak your project's language.
You don't need to write the glossary up front. Start grilling and the skill mints terms as you go, then offers to update the code to match, peeling back "a little window of sanity" in a messy codebase.
The second artifact is Architectural Decision Records (ADRs): short Markdown notes recording important, hard-to-reverse decisions. Code shows only the present; ADRs preserve the past so the agent doesn't repeat old mistakes. His video-editor repo has 31 of them.
The skills are free at aihero.dev/skills.
Step 3: Stay in the "smart zone"
After grilling, you choose a path based on size, and here Pocock introduces a concept credited to Dex Horthy: the smart zone and the dumb zone.
As a context window fills, attention degrades and the model makes worse decisions, even well short of million-token limits. Pocock starts getting nervous around 150,000 tokens. He stresses that the exact number matters less than the instinct, a healthy "context paranoia." Smaller contexts are smarter, faster and cheaper, since every follow-up re-pays for the whole history.
So:
- Small job that fits in the grilling session's context: run the implement skill.
- Big job: turn the conversation into a spec, a Markdown file or GitHub issue defining the destination, then split it into tickets, each sized to fit roughly within that smart zone. Each ticket gets its own fresh session.
A skill called implement-spec can run tickets with parallel sub-agents in git worktrees, merge the results and produce one large pull request for review. Tickets are tracked as GitHub sub-issues under the spec.
He also notes that big codebases don't necessarily eat more context. Poorly organized ones do. A small, tangled repo can be harder to explore than a large, well-structured one.
Step 4: Stop maxing out effort
Here's a contrarian tip that could cut your bill. Pocock thinks there's "an epidemic" of developers running models at the highest effort settings for everything.
More effort makes sense for a painting or an animation. But for exploring a codebase, more effort just means reading more files when it should be reading the right ones, and burning context so you hit the dumb zone sooner.
His default is Claude Opus 5.5 on medium effort, and he's considering low. He raises effort mainly for web research, performance testing, tricky debugging and, crucially, verification, when an agent checks its own work by clicking through the app or running performance traces.
He runs a single Anthropic subscription, doesn't hop between models much, and argues most people would gain more from fixing the environment than from waiting for the next model: "Why not just fix all your problems?"
Step 5: Adversarial code review
Pocock assumes his agents will get things wrong. That's fine, because a code review skill runs an adversarial review on two axes:
- Spec review. Did it build what the spec asked for, or drift over or under scope?
- Standards review. Does the code follow the repo's coding standards file? His includes rules such as "every
anyin TypeScript is a leak."
He gently calls out the habit of telling an agent to "create standards, I don't want to look at them." That, he says, is still vibe coding: wishing for good results without defining them.
Step 6: Judge merge danger: one-way vs two-way doors
For important work he adds human review, guided by a PR skill that writes a pull-request description with a visual summary, evidence that it works (screenshots or execution results) and a merge danger rating:
- Two-way door: easy to undo. Merge, test in production, revert if needed.
- One-way door: irreversible, such as data loss or an email blast to 100,000 people.
- Blast radius: how bad it is if it goes wrong.
Small blast radius plus two-way door? Light review. One-way door with a big blast radius? He tries hard to break it.
Step 7: Retro: the ratchet
Every human review comment is a clue about how to improve the environment so you never write that comment again. A retro skill looks back at a session or PR and proposes improvements.
The key principle: always prefer determinism. If a lint rule can catch a problem every time for free, that's better than asking the agent to remember a rule. Each retro ratchets automated checks tighter until the agent is in a "straitjacket" and can barely make the mistake at all.
The trust ladder
All of this serves one goal: trust. Pocock cites Lauren Tan, a developer known for shipping thousands of pull requests a month, on climbing a "trust ladder." If you don't trust your agents, you'll top out at a few at once because you'll watch everything. Build the right environment and you can run many agents comfortably.
A good codebase, in the classic books' definition, is one that's easy to change without breaking things. That requires feedback loops so agents can grade their own work:
- Strong types, so TypeScript rather than JavaScript, so mistakes surface instantly.
- Fast, meaningful tests that verify runtime behavior.
- Strict linters that block known bad patterns.
- Self-verification at high effort.
He's comfortable merging much of his own work with minimal review because he builds personal software, not banking or medical systems. In finance, he says, he'd spend heavily on security verification and scrutinize every one-way door.
Deep modules and tests that matter
Pocock's favorite architectural idea is Ousterhout's deep modules: large chunks of functionality behind a narrow interface, tested from the outside.
Bad tests mirror implementation details, say a test that only checks a tweet limit constant equals 240. Change the code and the test churns. Good tests exercise a deep module through its entry point, so you can rewrite the internals freely. Then you can "turn the lights off" inside that module and stop worrying about it.
His improve-codebase-architecture skill scans a repo's hot spots and produces an HTML report. In the live run, it found two features sharing about 150 nearly identical lines and proposed consolidating them into a single deep, testable module. He runs it daily as a scheduled job on each repo through GitHub Actions, letting it open small improvement PRs, two-way doors, and spot-checks roughly every fifth one.
He doesn't believe in a fully "dark factory" where nobody looks inside. He prefers dimmer switches: rooms you rarely enter, but can.
Starter stack for beginners
For someone with an app idea and no background:
- GitHub, VS Code, Git and any agent that supports skills. Skills are a common standard now, so the harness matters less than you'd think.
- Hosting: use the easiest platform, Vercel, Netlify or Cloudflare, rather than raw cloud consoles full of foot-guns. Push to GitHub and it deploys.
- Data: if unsure, use Postgres on a managed service such as PlanetScale or Supabase.
- CI/CD for deployment. It's deterministic, costs no tokens and has been a solved problem for years.
- Security: add a security pass to your code review. Many harnesses include a built-in security review.
Open source in the era of slop PRs
Contributing to open source used to be the classic way to prove yourself. Now it's harder. AI makes low-effort pull requests so cheap that popular projects are closing the door. Hono, a widely used JavaScript server framework, stopped accepting PRs from non-collaborators in October, and Pocock has closed PRs on his skills repo.
The new etiquette: contribute high-quality issues with solid reproductions. Pocock triages incoming issues with an agent that tries to reproduce each in a dummy repo before drafting a fix, and filters out junk.
And use open source to learn. Point your agent at a great codebase and ask it to teach you what that project gets right strategically.
What new developers should learn
His advice for students and career-changers:
- Show you care about strategy. Build something real, like a small CRM, make it fast and polished, deploy it and let people click through it.
- Learn the vocabulary, not a language. Terms like locality, deep modules, layout shift and hydration errors let you direct agents precisely. An expert says "fix the layout shift on the homepage"; a beginner describes symptoms for a paragraph.
- Read the classics: A Philosophy of Software Design (Ousterhout), The Pragmatic Programmer (Thomas and Hunt), Working Effectively with Legacy Code (Feathers), Refactoring (Fowler) and Extreme Programming Explained (Beck). Use an AI tutor for the dense parts. Pocock's teach skill builds quiz-driven HTML lessons; it even taught him to solve a Rubik's cube.
- Degrees? He questions whether CS degrees were ever the deciding factor. The real divide is between people who care and people who don't.
What would make him hire? Strategic thinking, the right language and attention to product quality. Tokens don't differentiate products, he argues; human attention, use and observation do.
Software factories, and their brakes
A software factory removes humans from more steps: an issue or a slow-database alert triggers an agent, which decides whether to act; two-way-door changes merge automatically and only one-way doors need people. It's "loop engineering by another name." The danger is a "slop cannon," which is why the strategic layer, the environment and the brakes, matters more as you speed up.
Beyond code: the hardest part is knowledge work
Pocock uses agents for life too. A scheduled job every few hours pulls in mentions and messages from his audience into a private, LLM-maintained wiki, which he queries to find what people want to learn. But when it's time to design a course, he goes offline: printed learning goals on cards, rearranged by hand for hours. Agents are too fast, or too slow, for that kind of thinking.
His closing observation flips the rest of the conversation. Coding is easier than people think because it's verifiable. Knowledge work, such as whether a course or script is better than the last, is much harder, because there's no test suite for it. Expect that wall to matter over the next few years.
FAQ
What are Matt Pocock's skills? Free Markdown "skills" for coding agents, including grill-me, grill-with-docs, implement, code review, retro and improve-codebase-architecture, documented at aihero.dev/skills.
What is the "dumb zone"? The part of a long context window where a model's decisions degrade. Pocock tries to keep sessions under about 150,000 tokens.
Which model and effort does he use? Claude Opus 5.5 on medium effort for most work, higher effort for verification, research and debugging.
Do I need to learn a programming language to build software with AI? Not deeply, in his view. Learn to read code, understand module boundaries and the vocabulary of good design.
What's a one-way door? A change you can't easily undo, such as data loss or a mass email. Those deserve careful human review.
The bottom line
Agents have made tactical coding nearly free. Pocock's argument is that this makes the strategic layer, shared language, specs, small contexts, adversarial review, deterministic checks and deep modules, the scarce and valuable skill.
You don't need a CS degree or a favorite language to learn it. You need the vocabulary, a few classic books, a workflow that forces alignment before code, and the stubborn habit of making your agents' environment a little better after every session. In his word: care.





