Non-technical founders have an unfair advantage with AI agents
Five principles that turn AI agents from slop machines into product factories. Companion notes for this week's conversation with Isaac Askew and Jeffrey Sherman on Never Rewrite.
Watch the full episode here: Never Rewrite - Agentic Development Is Turning Engineers Into Product Owners
This post covers the general opinions I carry right now. If you’re a non-technical SaaS founder trying to figure out where AI fits in your dev arrangement, this is for you.
The thesis is:
managing AI coding agents is the same skill as managing developers.
If you can do one, you can do the other.
The corollary nobody is saying out loud is that non-technical founders have an unfair advantage with agents, because they’ve already been forced to learn how to delegate without prescribing.
I spent the last several years running an agency that delivered production B2B SaaS with human engineers before AI and then a mixed team of human engineers and AI agents.
What surprised me was that the management discipline turned out to be the same one I’d been teaching non-technical founders the whole time.
Here are the five themes I continue to see repeating..
1. The prescription trap
The most common failure mode for technical people with AI agents is the same failure mode product managers have with engineers. They tell the agent how instead of what.
Vague prompts produce garbage. Too-literal prompts also produce garbage, because the agent’s ability to make tradeoffs has been stripped out.
The skill is being precise about what you want and loose about how it gets done. That’s the whole game.
2. Completed staff work
Don’t let the agent jump straight to code. Make it research the problem, propose three options, and recommend one. It’s the same thing you’d ask of a good junior dev: come back with options and a recommendation, not a question.
This habit forces the agent to surface assumptions you didn’t realize you were making. You catch the wrong premise in the planning step, where rework costs minutes. Catching this at the end in testing wastes time and tokens.
3. Demo the result, don’t read the diff
With human developers, you might read the pull request. With AI agents, you can’t. They ship ten times the code. The workflow non-technical founders use already scales for this: have the agent demo the working thing.
The deeper point lands hardest with technical founders. Non-technical founders were forced into this discipline years ago because they couldn’t read code. Now technical founders are catching up to a habit they used to look down on.
That doesn’t mean skip code review. In a healthy setup, every pull request runs through static analysis and a review agent first. A human reads the pull requests that touch Mission Critical Paths.
4. Principles are not prescriptions
This is the line founders miss. “Don’t prescribe” doesn’t mean “no guardrails.” It means the opposite. You need strong principles, baked into the architecture, that constrain the solution space without constraining the solution.
A principle constrains the solution space. A prescription constrains the solution.
Two concrete examples:
Full-stack TypeScript when building a web app, unless there’s a real reason not to. One type system spans webapp, API, mobile, and every other client. The agent and every human on the team operate from one mental model.
A design system with reusable components. That means a good table view, a data viewer, and form primitives. The agent composes new screens from existing parts instead of hand-writing every table; the UI stays visually consistent for free.
Layer hard requirements on top. Junior devs need rules. Senior devs need principles. AI agents need both, plus a small list of non-negotiables (never commit secrets, never skip tests, never touch production directly) that act as the floor.
5. Decompose, one-shot, compose
Big tasks produce slop. The agent can actually nail a small, bounded job. Decompose the work into bounded pieces, one-shot each one, then compose the results into production-quality work. Ask it to “build the whole feature” and it loses the plot, the same way a junior dev crushes tickets and chokes on epics.
The same pattern applies to building a team. Founders go hunting for the unicorn who does design, ops, sales, and product. That person doesn’t exist, or costs a fortune, or burns out. The real answer is a small team of specialists, each excellent at their one thing, with clean handoffs between them.
Whether the unit is a prompt, a service, or a person, the principle is the same.
Watch the Full Episode of Never Rewrite
What’s next
This is the working summary. The deeper essay, on where the “Dark Factory “ pattern came from, who’s publicly building it right now, and how I’m using the pattern to rebuild my agency, lands on Better Every Cycle next week.
Subscribe if you want the long version when it drops.
In the meantime, the full conversation is here: Never Rewrite - Agentic Development Is Turning Engineers Into Product Owners