The method that isn’t vibe coding.
The short version
A small team I led recently shipped a greenfield project in three weeks. We did not write better prompts than anyone else. We did something more boring: we built the system around the models. A good PRD, a structured harness, defined quality gates.
I want to give that approach a name, because “vibe coding” undersells it. I call it APE: Agentic Product Engineering.
Yes, the acronym is deliberate. It nods to evolution. Mostly it stops you calling a discipline “vibes.”
Why not just “vibe coding”?
Andrej Karpathy coined “vibe coding” for one person talking to an AI until something works. It is real and it is useful. I use it for prototypes, for exploration, for Saturday projects.
It does not ship production software with a team.
Here is the contrast that matters:
| Vibe coding | Agentic Product Engineering (APE) | |
|---|---|---|
| Who | One person + one AI | PM + Design + Engineering + agent teams in parallel |
| Starting point | A prompt | A PRD with acceptance criteria per phase |
| How code gets written | Conversation until it works | Structured agent teams on branches; humans review diffs |
| Quality bar | Whatever runs | Coverage gates (CI-enforced), static analysis, security review |
| Architecture | Emergent, often missing | Architectural decisions recorded before or during implementation |
| What humans review | Does it work? | Is this the right thing to build? Does the architecture fit? |
| Learning across sessions | Resets each time | Reflections feed a shared agent context file, so later phases start with knowledge earlier phases didn’t have |
| Output | Usually a demo | Live production system |
Both columns use the same AI. The difference is the discipline around it.
Vibe coding works for one person over one weekend. APE works for a team, a quarter, and a production system. You pay up front: a good PRD, a structured harness, defined quality gates. Every later phase builds on that work.
The three shifts
1. The spec carries the most weight
Most AI workflows fail for the same reason most software projects fail: the spec was vague.
A vague spec slows one agent down. Run 3–5 agents in parallel and it multiplies errors across all of them. Each agent reads the ambiguity a different way. By the time you notice, you have five implementations of the same half-formed idea.
In APE, the PRD does not sit in a backlog. It is the brief the agent team acts on. A well-written PRD is worth ten clever prompts.
The fastest way I have found to sharpen a fuzzy spec is to get interrogated about it. Matt Pocock’s “grill me” skill does exactly that. The agent questions your assumptions, edge cases, and contradictions until a fleet of agents can act on the spec without guessing. Run it before you spawn anything.
2. Agent teams with file ownership
One file, one owner. Every phase gets a structured team:
- A Team Lead agent that breaks down the work
- Several implementation agents with explicit file boundaries (“Agent A owns the API layer. Agent B owns the frontend.”)
- A reviewer agent that runs on every completed task. It runs typecheck, lint, and tests, then reads the actual diff for problems tests would miss.
In one of our final batches, the reviewer caught real bugs before any human opened the PR. The test suite missed them because the bugs sat in code the tests did not exercise. A reviewer agent that reads the diff catches problems unit tests were never designed to catch.
3. Humans review intent, not mechanics
This is the biggest cultural shift, and most engineers underestimate it.
Your question moves from “is this code correct?” to “is this solving the right problem? Does the architecture fit? Is there a security concern the tests can’t catch?”
The agents handle syntax, tests, and typechecking. You handle judgment.
Many engineers find this uncomfortable. “I write code” is a strong identity. APE does not take coding away. I still code every day. But most of the gain comes from the work you do around the code, instead of writing every line yourself.
The harness matters more than the model
This section matters most.
We all use the same models: Claude, GPT, Gemini, whatever ships next month. If you think your edge comes from the model you picked, you will lose to someone who asked the question underneath: what surrounds the model?
What surrounds the model is the harness. The environment it runs in. The tools it can call. The feedback loops it can reach. How state carries between sessions. How work gets scoped, assigned, and verified. Addy Osmani has made the case for this louder and more clearly than anyone. Much of how I think about harness engineering and the levels of AI-assisted practice traces back to his writing.
Case study 1: Anthropic’s own coding agent
From Anthropic’s engineering blog, verbatim:
“We actually spent more time optimizing our tools than the overall prompt.”
Their example: the model made mistakes with relative filepaths after the agent moved out of the root directory. They tried prompting around it. It didn’t stick. The fix was to change the tool to require absolute filepaths. After that, the model used it flawlessly.
That was a tooling change. Prompting had already failed.
Case study 2: a pattern you’ll hit yourself
We built an AI-driven scaffolding tool. You describe a thing, and it generates a working project. Early versions failed constantly: wrong config files, mismatched versions, malformed build setups. We burned hours trying to prompt-engineer our way out.
The fix was the environment. We pre-mounted a stable, known-good project scaffold before the AI wrote a single line. The AI only touched the parts unique to what the user described. Generation failures dropped to near zero.
Same pattern as Anthropic’s. When the output is flaky, the fix usually sits upstream of the prompt.
The diagnostic questions to ask
- Does the tool return information in a format the model can reason about? Or does it make the model count lines in a diff?
- Can the agent verify its own work? Or does it just claim “done”?
- Does the environment give the agent a stable starting point, or does it have to rebuild state every session?
- Are the tools generic (grep, git, npm, things the model has millions of training examples of) or bespoke (custom schemas the model has to learn from scratch)?
Vercel published numbers on that last question. They replaced the specialised tools in their text-to-SQL agent with a single generic batch command. The result: 3.5× faster, 37% fewer tokens, success rate from 80% → 100%.
Each fix above changed the harness: a generic tool, a simpler format, a stable environment. None of them needed a better model or a cleverer prompt.
Invest in the harness first. Tune the prompt last.
Product, Design, and Engineering change together
The biggest shift APE brings is not technical. It is how Product, Design, and Engineering work together.
The old model is sequential. PM writes a spec. Design creates mockups. Engineering builds. Review. Rework. Each role waits for the previous one. Feedback arrives late. Rework is expensive.
The APE model is parallel. All three roles work at the same time. Each role’s output feeds the agents directly.
Product Managers write PRDs that serve as the agent team’s brief. They can prototype ideas with AI to validate them before engineering starts. The shift: from specifying how to build to specifying what and why, clearly enough for an agent to act on.
Designers encode the design system once in an agent-readable context file: tokens, conventions, anti-patterns, brand voice. Agent teams read it before they generate any UI code. Components come out visually consistent without a designer reviewing each one. The shift: from reviewing every implementation to encoding the system once, then reviewing intent and system fit.
Engineers orchestrate agent teams instead of writing every line. They write the PRD, set constraints, and review diffs. The shift: from individual contributor to director of a team that happens to include agents.
What stays entirely human: deciding what to build and why. Judging whether it solves the right problem. Making tradeoff decisions under uncertainty. Catching wrong assumptions in intent review.
The trio stays the same size. Each role starts earlier and works at a higher level of abstraction than before.
Build a pit of success
Apply harness thinking to code safety and you get one rule: make the right thing easy and the wrong thing loud.
Most projects have rules like “always filter by tenant ID” or “always validate input before it hits the database.” Those rules live in the developer’s head. Forget one once and you have a bug, a leak, or a security incident.
The APE alternative: push the rule down into a layer where forgetting is impossible. A scoped client that refuses to run unscoped queries. A type system that rejects unsafe column names. A validator that blocks the deploy if a migration is missing the required columns. You cannot do the wrong thing, because the wrong thing is a compile error or a deploy failure.
APE applies this principle everywhere. Agents will make mistakes. Your job is to design systems where those mistakes are loud. Humans make the same mistakes. Agents make them faster and in parallel.
What you can do Monday morning
If you want to try APE on a real project, here is the order I’d start with:
-
Write a real PRD. Not a ticket. A document with user stories, acceptance criteria, and architectural decisions. This step pays back more than any other. Use AI to help draft it; that is a good use of vibe coding.
-
Set up a project-level agent context file. Build commands, folder structure, architecture constraints, security-sensitive boundaries. Every session reads it first. Keep it lean.
-
Set up a persistent learnings file. Start empty. Let it grow from reflections after each phase. Keep it human-curated. Research shows LLM-generated rule files offer no benefit.
-
Try one agent team on one phase. Not your whole project. Pick a greenfield slice with clean file boundaries. Spawn a few agents with explicit file ownership and a reviewer. Watch what breaks. Fix the harness, not the prompt. (Here’s a real parallel-review session where the reviewer agent caught bugs the tests missed.)
-
Invest in tools before prompts. When output is flaky, start with the diagnostic questions above.
The edge isn’t the model. It never was. Teams that ship faster and cleaner with AI aren’t prompting harder. They build better harnesses.