As a Founder earlier this month I ran a small but serious experiment. While the team kept shipping the main Interacty product, I set aside two weeks (forty focused hours) to rebuild a meaningful slice from scratch using only an AI coding agent. No hand-typed code. My job was to think, specify, review, and understand how that may help in strategy.
You keep your hands off the keyboard and drive by intent, constraints, and taste. The agent writes, you conduct.
The result was a working demo that got my team genuinely excited. Below is the playbook that emerged. It won’t be timeless (this space moves too fast) but it’s useful right now.
Set roles before you touch code
Create two separate agents with two separate contexts. One plays CTO, one plays Coder. The CTO agent’s output is a plan: scope, milestones, interfaces, acceptance criteria. The Coder only receives the next task in the plan, plus the minimum context required to execute it.
Why this helps: a single giant prompt drifts. Two specialized roles keep thinking and implementation from melting into one soup. You get cheaper re-planning, clearer diffs, and fewer "oops, we forgot X" moments.
Decompose until you’re slightly bored
Most first prompts hide blank spots. Force yourself to split the work until each step feels a little too small. Write the interface first, then the adapter, then the UI binder. Push each step through the CTO agent, adjust, and only then feed the Coder. You’ll spend more time up front and save it back when you don’t have to untangle a 2,000-line diff that mixed five concerns.
Sometimes the best prompt is "no code"
When I wasn’t sure about an approach, I told the Coder: "analyze only-no code." The agent walked the repository, called out weak spots, and proposed alternatives. These analysis passes surfaced hidden coupling, risky global state, and places where a contract was implied but never written down.
Review like an engineer, if you can
Even if you don’t type code, use your engineering taste. I reviewed every PR-sized chunk, asked the agent to explain trade-offs, and rolled back twice when the explanation didn’t hold up. Treat explanations as part of the artifact. Git diffs gave me insught, new ideas and we made new iterations after reverting.
"Do it like them" is a great spec
Our product is UI-heavy. Instead of vague prose, I anchored requirements in known patterns: "infinite canvas like Figma," "drag-to-reorder like Notion," "command bar like Linear." The Coder produced closer first drafts when I referenced concrete patterns and behaviors users already know.
Isolation is oxygen
Obvious, but the agent fights you here. Left alone, it will reach for global helpers and shared singletons because they’re easy inside a small context window. Insist on crisp module boundaries and explicit contracts. Keep adapters thin and swappable. Document inputs/outputs in the task itself so the agent can regenerate a module without reading the whole repo.
Two reasons this matters:
- Context limits. The window is never as big as your codebase. Isolation lets the agent fix things locally.
- Quality drift. Globals make quick wins feel great and maintenance feel impossible. Contracts prevent that slide.
Turn the agent into your QA lead
We had some existing tests, but in vibecoding the "tester" role shifts to you. I wrote explicit test prompts with exact steps, expected outputs, and stack traces when things broke. The Coder responded well to precise failure stories. When it got stuck after a few tries, nudging the strategy helped: "You’ve tried the same fix three times. Change approach. Consider the reducer, not the effect."
The minimal vibecoding loop
- Define the unit. One task, one contract, one acceptance test.
- Plan with CTO. Validate scope and interfaces. Adjust.
- Code with Coder. Provide only what’s needed.
- Explain. Ask for the reasoning and trade-offs.
- Test. Provide exact repro steps and errors.
- Decide. Merge, revise, or roll back.
Guidelines I’d reuse tomorrow
- Contracts before code. Function signatures and error shapes beat screenshots and vibes.
- Thin adapters. Keep boundaries boring and obvious.
- Named patterns. "Like Figma canvas" beats "intuitive editor."
- Analysis passes. Permit "no code" prompts when uncertain.
- Explanations as artifacts. Store the agent’s rationale next to the PR for future maintenance.
- Reset strategy on loops. If three fixes fail, force a different angle.
What this means for us
This demo won’t ship as-is. But it gave our team a clear vision of where AI belongs in our core processes and where it doesn’t. We’ll keep vibecoding, with stronger boundaries, better tests, and a stricter split between planning and coding.
Vibecoding isn’t magic. It’s leverage. If you bring clear taste, contracts, and discipline, forty hours can move a real product. Without that, it’s just noise that compiles.
Artem Grishanov