The Manual I Wish I Had Before Automating My AI Workflow

1. The “Just Do It” Trap (And why I now insist on Plan Mode)

It’s easy to get intoxicated by the speed. You start trusting the agent, your prompts get shorter, and you’re running five things at once.

The result? Hallucinated architecture. I’d open the code and realize that while it “worked,” it wasn’t what I wanted.

Now, I don’t move a muscle without Plan Mode. In tools like Cursor, I use ⇧ Shift + ↹ Tab religiously. It forces me to react to the intent before the implementation. It saves tokens, but more importantly, it saves me from having to undo a “fast” mistake that takes an hour to untangle.

2. Moving Beyond “Disposable” Prompts

I used to treat prompting like a Google search: type it, use it, forget it. That’s a mistake. It forces you to repeat your architectural preferences and constraints every single hour.

I’ve switched to a Continuity Model. I maintain a custom ChatGPT Project loaded with my specific codebase DNA—PDFs, Reddit threads from my target audience, and deep documentation. Now, my prompts aren’t just requests; they are the result of accumulated context. If you don’t provide the context, the LLM will fill the gaps with its own assumptions. You don’t want that.

3. Hiring “Skills,” Not Just Writing Rules

I’ve moved away from bloated AGENTS.md files in favor of Agent Skills. Think of a skill like a pre-vetted colleague you hire for a specific task. It’s reusable knowledge that works the same way every time. Defining these skills forced me to actually articulate how I work best, which made me a better developer even when the AI is off.

4. Reclaiming the Pilot’s Seat (Model Choice)

“Auto mode” is a trap for the lazy. For the heavy lifting, I manually switch to high-reasoning models. I’m not just looking for a “smart” answer; I want the “hidden work”—the explicit thinking process. I use the expensive models to build the perfect plan, then let the faster, cheaper models handle the typing. Garbage in, garbage out still applies, even in 2026.

5. The Danger of the “Mega-Prompt”

It’s tempting to ask the AI to “build the entire feature.” Don’t. Large prompts create massive diffs. Massive diffs are where bugs hide and quality dies. I now run multiple agents with tight, focused scopes. I’d rather have five small, perfect PRs than one giant, “mostly-okay” mess.

6. The “Indie Dev” Accountability Gap

When you’re an indie dev, you can push to main and nobody screams. But AI agents amplify your lack of discipline. I learned this the hard way with my app, Vydio; the code quality tanked because I wasn’t reviewing the AI’s “quick fixes.”

Now, I treat the AI like a junior dev on a high-stakes team. I use PRs, I run linters, and I perform manual reviews. The AI doesn’t remove the need for a lead dev—it makes the lead dev more important than ever.

7. The 1% Rule for AI Tooling

I make it a point to learn one deep-level feature of my IDE (Cursor, Codex, etc.) every day. Shallow usage leads to blaming the tool. Deep usage gives you leverage. Speed is great, but predictability is the real gold mine.

8. Guardrails are Freedom

An agent without constraints is a loose cannon. I’ve leaned heavily into SwiftLint and automated rules. Constraints don’t slow the AI down; they prevent it from inventing its own (usually wrong) way of doing things.

9. The Living “Environment”

If an agent makes the same mistake twice, I don’t just fix the code. I fix the environment. I tell the AI: “Fix this, then update my AGENTS file so this never happens again.” My environment now automatically runs tests and linter checks before the agent is even allowed to say “Done.”

10. The “Context-Free” Review

AI can produce code that looks “plausibly right” but is fundamentally broken. My secret weapon? I have a separate agent review my PRs with zero context. If a “fresh” agent can’t understand the change, a human maintainer won’t either.

11. Embracing the Friction

I hate CLI tools. But I forced myself to use the Codex CLI just to see the hype. I ended up hating it—it’s not for me—but that discomfort led me to discover better ways to structure agent skills. Stay curious, even when it’s annoying.

The Bottom Line: AI-assisted coding doesn’t offload your responsibility; it scales it. Every vague instruction or skipped test is a debt you’ll eventually have to pay with interest. Optimize your workflow today, and the productivity gains will compound for years.