I'm Theo. I code out of pure passion for over 2 decades, specialized in webdev.
Building something innovative usually comes down to one of two things: you are creatively combining pre-existing concepts into a new "soup" or you are actually finding entirely new paradigms.
Let's be brutally honest: right now, AI is mediocre at best on designing new ideas, with rare and random sparks of genius. But there is a massive exception. Given a crystal-clear specification, AI possesses super-human implementation capabilities.
Recently, I've been using AI tooling to build a new innovative framework (Runner). I've had incredible successes, spectacular failures, and learned exactly where the limits lie. The framework itself is designed to be the next level of backend structure for large apps, basically, a way to keep chaos on a leash when you have massive feature throughput.
If you are building complex systems with AI, here is the exact workflow, prompt structure, and harsh reality check I use to ship without losing my mind.
I manage the AI's behavior using two specific markdown files in my repository.
The Evolving AGENTS.md
This file dictates how the AI should act.
It started with just one line -> "Be passionate about what you do, be thoughtful, clear and precise."
The "Rule of Two" says if the AI makes a mistake that annoys me more than twice, it becomes a permanent rule in AGENTS.md.
No Yelling -> If a problem persists, I re-iterate the rule in different wording (and different placement) rather than screaming "SUPER IMPORTANT!!!" in all caps.
Context Refueling -> If the token context of a chat reaches > 70%, the AI starts forgetting its personality. I manually re-inject @AGENTS.md into the chat to keep it on track.
catch(exception): When dealing with the high-level development workflow, they are immediately added into AGENTS.md (qa scripts, coverage, working with other agents at the same time in same worktree, etc)
The Dense AI.md
For the framework's mechanics, I created an intentionally minimal, extremely dense documentation (which is now at 7000 tokens) file called AI.md.
Whenever I start a new task, the agent is given this file to read. Even if AGENTS.md specifies it, I still manually attach AI.md to the initial prompt. I've noticed the results are exponentially better when it's shoved right in front of the model.
The 8-Step AI Coding Workflow
You can't just say "build the app." You have to treat the AI like a junior developer who works at lightning speed but lacks architectural foresight. Here is my daily loop:
- Exploration: Discuss an idea, find the drawbacks, and align on the vision.
- Plan Mode: Craft the architectural plan before writing any code.
- Plan Review (Optional): Ask the AI to spawn sub-agents to critique its own plan. (I use it for high-risk, high-complexity only)
- Implementation & QA: Execute the plan and demand a full QA pass (I have a single qa script which checks: 100% coverage, lints, strict type-checking).
- Implementation Review: Spawn a sub-agent to review the written code specifically for simplification, optimization, and clarity (subagents are important because they remove initial biases).
- The Second Opinion (Optional): For (high-risk || high-complexity), I ask completely different AI model to get an outside perspective.
- Human Review: I review the code/tests myself, going back and forth with the AI for final micro-adjustments.
- Commit: Generate the commit message with AI, review it, and push.
Surviving the "Boring Zone"
When an app/library becomes incredibly complex, you naturally forget the tiniest details of how certain flows work. Instead of jumping between 15 files to reconstruct the logic in my head, I ask the AI to dig it up and present it with clickable file references. It gets me back into the "zone" instantly.
More importantly, AI completely eliminates the soul-crushing cost of low-to-medium cognitive tasks - like massive refactors that span 50+ files. Work like that is boring, dissatisfying, and is exactly what leads to project abandonment (especially in open-source projects with no immediate path to revenue). AI gives you wings right when you would otherwise quit.
Why You Must Be the "Code Janitor"
If you're going to adopt this, you need to be cautious.
AI will confidently lie to you. When you have a streak of 10 AI successes, you tend to blindly trust the 11th. Don't. Always take the output with a grain of salt.
An AI's only goal is to finish the prompt. It will take shortcuts and write non-elegant code to get there. Your job shifts from being just a coder to being a Code Architect and a Code Janitor.
Never let a single AI instance brainstorm alone. Specifically prompt it to: "Spawn 5 sub-agents with different personalities and skillsets to brainstorm this, debate it, and give me a pre-validated report." The quality difference is uncomparable.
AI models have a terrible tendency to over-engineer and over-defend their bad code. Sometimes, all it takes is a simple "Are you sure?" to make them immediately re-assess and admit they were leading you down the wrong path.
The Cognitive Load Paradox
Previously, after a few years in a stack, writing boilerplate code became basically relaxation. You had your plan, you had your todos, you put on some music, and you just typed.
Using AI actually makes the cognitive load harder. You are no longer the typist; you are a rapid-fire reviewer and architect constantly evaluating logic. You can still write code the old-school, relaxing way, but once you realize you can build faster using this workflow, it becomes impossible to go back.
--
If you have any productivity tricks, I'd love to hear more ways you effectively applied AI to your work.
Top comments (1)
The "Rule of Two" for AGENTS.md is solid — we landed on a similar pattern where repeated AI mistakes become permanent guardrails in a config file. Curious how you handle the context refueling at 70% when tasks span multiple sessions?