Most developers use AI wrong.
They type a prompt, get code, paste it, fix the bugs, repeat. It's autocomplete with extra steps.
But AI can do so much more when you give it modes.
- Plan Mode: Think before you code
- Execute Mode: Autonomous implementation
- Critique Mode: Multi-model review
This is how AI-assisted development was meant to work.
The Problem with Promptless AI
The Current Workflow
Developer: "Write a function to validate emails"
AI: [generates code]
Developer: [pastes code]
Developer: [tests it]
Developer: "It doesn't handle edge case X"
AI: [generates new code]
Developer: [pastes again]
...repeat 5 times
You're doing the thinking. AI is just typing.
What's Missing
- No planning — AI doesn't know your codebase
- No context — Each prompt starts fresh
- No verification — You're the only reviewer
- No autonomy — AI waits for every instruction
It's a fancy typewriter, not a pair programmer.
Mode 1: Plan
Before writing a single line of code, the AI maps out the approach.
How Plan Mode Works
You: "Add user authentication to the app"
AI (Plan Mode):
1. Analyzing existing codebase...
2. Found: No current auth, using Next.js, Prisma ORM
3. Recommended approach:
- Add NextAuth.js for authentication
- Create User model in Prisma schema
- Add login/signup pages
- Protect routes with middleware
- Store sessions in database
4. Files to create:
- app/api/auth/[...nextauth]/route.ts
- app/(auth)/login/page.tsx
- app/(auth)/signup/page.tsx
- middleware.ts
5. Files to modify:
- prisma/schema.prisma
- lib/auth.ts (new)
6. Estimated changes: 8 files, ~400 lines
Approve this plan?
Why Planning Matters
- Catches bad approaches early — Before you write 500 lines in the wrong direction
- Shows the full scope — Know what you're getting into
- Maintains consistency — AI follows your existing patterns
- You stay in control — Approve before execution
When to Use Plan Mode
- New features
- Major refactoring
- Unfamiliar territory
- Anything touching > 3 files
Mode 2: Execute
Once the plan is approved, AI works autonomously.
How Execute Mode Works
Plan approved. Executing...
[Creating] app/api/auth/[...nextauth]/route.ts
[Creating] lib/auth.ts
[Modifying] prisma/schema.prisma
[Running] npx prisma generate
[Creating] app/(auth)/login/page.tsx
[Creating] app/(auth)/signup/page.tsx
[Creating] middleware.ts
[Running] npm run build
[Testing] Auth flow...
✓ Build successful
✓ Login page renders
✓ Signup creates user
✓ Protected routes redirect
✗ Session not persisting (fixing...)
[Modifying] lib/auth.ts - added session callback
[Running] npm run build
✓ All tests passing
Execution complete. 8 files changed.
What Makes Execute Mode Different
- Multi-step operations — Not just generating code, but running builds, tests, migrations
- Self-correction — Errors trigger fixes, not just error messages
- Real integration — Code goes into your actual files, not a chat window
- Verification — AI confirms the feature works before reporting done
When to Use Execute Mode
- After plan approval
- Bug fixes with clear scope
- Repetitive tasks (generate 20 components)
- When you trust the plan
Mode 3: Critique
Multiple AI models review the work, debating until consensus.
How Critique Mode Works
Running critique on: user authentication implementation
Agent 1 (GPT-5 - Security Focus):
- ✓ Password hashing looks correct
- ⚠ Rate limiting not implemented on login
- ✗ Session token in URL parameter is vulnerable
Agent 2 (Claude - Code Quality):
- ✓ Clean code structure
- ⚠ Missing input validation on signup
- ⚠ Error messages could leak user existence
Agent 3 (Gemini - Best Practices):
- ✓ Following NextAuth conventions
- ⚠ Should add email verification flow
- ⚠ Missing CSRF protection on forms
Consensus (3/3 agree):
- Must fix: Session token vulnerability
- Should fix: Rate limiting, input validation
- Consider: Email verification, CSRF
Auto-fixing critical issues...
Why Multi-Model Critique Works
- Different perspectives — Each model has different training, catches different issues
- Reduced blind spots — What one misses, another catches
- Consensus signals importance — If all three flag it, it matters
- Automated fixing — Critical issues get fixed, not just reported
When to Use Critique Mode
- Before shipping to production
- Security-sensitive code
- Complex business logic
- Code you didn't write yourself
- After major refactoring
The Three Modes Together
Example: Adding a Payment System
Phase 1: Plan
You: "Add Stripe payment integration for subscriptions"
AI plans:
- Stripe SDK setup
- Webhook handlers
- Subscription model
- Checkout flow
- Customer portal
- 12 files, ~800 lines
You: "Approved"
Phase 2: Execute
AI executes:
- Creates all files
- Sets up Stripe
- Runs test transactions
- Verifies webhooks
- Self-corrects 3 issues
- Reports complete
Phase 3: Critique
AI critique:
- Agent 1: "Webhook signature verification is correct"
- Agent 2: "Missing idempotency keys on charges"
- Agent 3: "PCI compliance looks good"
- Consensus: Add idempotency keys
- Auto-fixed
Result: Production-ready payment system. You wrote zero lines of code.
Implementing the Modes
Without Proper Tooling (Hard Mode)
1. Plan: Manually prompt ChatGPT to analyze your codebase
(requires pasting code, losing context)
2. Execute: Copy code, paste into files, run commands manually
(back to being a code monkey)
3. Critique: Open Claude tab, paste code, ask for review
Open GPT tab, paste same code, ask for review
Manually compare responses
(tedious and incomplete)
With a UDE (Easy Mode)
1. Plan: Agent reads your codebase, proposes plan
2. Execute: One click, agent implements everything
3. Critique: Multiple models review automatically
The modes exist. The question is whether your tools support them.
Getting Started
If You're Using ChatGPT/Claude Directly
You can approximate the modes:
Plan prompt: "Before writing any code, analyze my requirements and propose a detailed implementation plan. List all files to create/modify and your approach for each."
Critique prompt: "Review this code for security issues, code quality, and best practices. Be critical. I want to find problems."
But you'll still be copy-pasting and managing context manually.
If You're Using an AI-Native Tool
Look for:
- Plan mode built in
- Agent execution (not just generation)
- Multi-model support for critique
- Codebase awareness (not just current file)
The Orbit Approach
Orbit implements all three modes natively:
- Plan mode in Agent tab
- Execute mode with autonomous operation
- Critique mode with multi-model consensus
No prompting tricks required.
The Mindset Shift
Stop thinking of AI as:
- Autocomplete
- Code generator
- Stack Overflow replacement
Start thinking of AI as:
- Architect (Plan mode)
- Implementer (Execute mode)
- Reviewer (Critique mode)
You're the technical lead. AI is your team.
Direct, don't type. Review, don't write. Ship, don't struggle.
The Future of Development
The three modes aren't a feature. They're a paradigm.
As AI gets better, the modes get more powerful:
- Better plans with deeper codebase understanding
- Better execution with fewer self-corrections needed
- Better critique with more specialized reviewers
The developers who master the modes now will lead the teams of tomorrow.
Plan. Execute. Critique.
This is how AI-assisted development works.
Everything else is just autocomplete.