The Auteur Framework
Direct the system.
Ship the work.
A practical methodology for turning AI capability into reliable, production-grade software—without confusing output for ownership.
The premise
AI can generate code. It cannot own the direction.
AI accelerates implementation, but it does not replace judgment: what matters, what to trade off, what to test, and when a solution is actually ready for users. The Auteur Framework is a system for keeping that judgment explicit.
It grew out of building Vivid Resume from scratch. The work required product strategy, technical decisions, QA, incident response, and constant context management. The principles below turn those hard-won operating habits into a repeatable practice.
The operating loop
Direction is a discipline, not a single prompt.
- 01
Frame
Define the problem, user, constraints, and evidence before asking for a solution.
- 02
Direct
Give AI an executable brief with an outcome, boundaries, and a definition of done.
- 03
Verify
Review the behavior, not just the diff—across implementation, edge cases, and user experience.
- 04
Learn
Capture decisions and failures so the next session starts with better context.
The framework
13 principles for AI-directed production work.
Use these as a working checklist—not a ceremony. The point is to make good direction easier to repeat.
- 01
Start with the problem, not the prompt.
Describe the user need and the decision to be made before choosing a solution.
- 02
Treat context as a production asset.
Keep requirements, decisions, constraints, and evidence available where the work happens.
- 03
Direct one coherent unit of work.
Use focused sessions with a clear scope, then close the loop before expanding it.
- 04
Specify outcomes and constraints.
Tell the system what success looks like, what must not change, and how it will be checked.
- 05
Ask before you prescribe.
Expertise can make you jump to implementation. Explore the problem space before locking in a fix.
- 06
Make plans executable.
A good plan names the files, interfaces, risks, sequence, and acceptance criteria—not just the idea.
- 07
Separate direction from execution.
Keep the human responsible for intent and judgment; use AI to accelerate research, implementation, and review.
- 08
Review from more than one angle.
Use independent passes for correctness, security, product intent, and maintainability.
- 09
Test the experience, not only the code.
Walk the paths a user takes, including awkward states, slow paths, and errors.
- 10
Let incidents write the next rule.
When something breaks, capture the root cause and turn it into a durable guardrail.
- 11
Ship in small, verifiable slices.
Make every increment testable end to end so progress stays visible and reversible.
- 12
Design for context continuity.
Leave a concise handoff: what changed, why, what remains uncertain, and what comes next.
- 13
Own the direction.
AI can make choices available. You remain accountable for the product, the quality bar, and the result.
Put it to work
Build with more leverage—without giving up authorship.
These principles are useful whether you are a founder, product leader, designer, or developer. Start with the work in front of you and make the next decision explicit.