05.29Methods

Vibe coding to vibe engineering: AI-assisted coding in early 2026

How AI-assisted coding moved from casual vibe coding to structured vibe engineering, and the tools, methods and multi-agent patterns of early 2026.

On this page

Summary
Part 1: key frameworks and tools
Part 2: practices and methods
Part 3: multi-agent orchestration
Part 4: a typical vibe engineering workflow

How had AI-assisted coding changed from casual "vibe coding" to structured "vibe engineering", and which tools, methods and orchestration patterns did practitioners rely on? AR Labs researched this question in March 2026 as background for our own practice of agentic engineering. The report surveys coding agents and AI IDEs such as Claude Code, Cursor, Windsurf and Codex CLI, the published methods of Simon Willison, Addy Osmani, Steve Yegge, Jeffrey Emanuel and Geoffrey Huntley, and the failure modes and industry figures practitioners reported.

Method: seven parallel research threads, synthesised into one report. Figures and claims are as practitioners reported them at the time; the report does not list its sources individually.

Summary

Practitioners describe a shift in AI-assisted coding from "AI as autocomplete" (2023-2024) to "AI as autonomous software factory" (2025-2026). The approach they now favour is agentic development: orchestrating fleets of specialised agents within structured, context-engineered frameworks.

The distinction between "vibe coding" (casual, trust-the-AI) and "vibe engineering" (structured, accountable, context-first) has become the line practitioners draw between amateur and professional AI-assisted development.

Part 1: key frameworks and tools

1.1 Claude Code (Anthropic CLI)

Status: Widely used as the "execution harness" for agentic software engineering.

Key features (early 2026):

Plan Mode (Shift+Tab twice): Locks agent into read-only architectural discovery. Agent maps dependencies and produces a written plan before any code is written. Human approves, then switches to Auto-Accept Mode for high-velocity execution.
Worktrees for parallelism (claude -w <branch-name>): Spins up independent Git worktrees. Multiple agents can work simultaneously (one on database layer, one on UI, one on tests) without context contamination.
Tasks and subagents system: Delegates to specialised agents in .claude/agents/:
- Spec-Validator: Clarifies requirements
- Draft-Implementer: Writes initial code
- Code-Simplifier: Post-implementation elegance refactor
- Verify-App: Runs tests, opens browsers via MCP to verify UI
MCP integration: The "connective tissue": connects to databases, Jira/Linear, web search, custom APIs. Standardised tool-use layer.
CLAUDE.md: Project memory file. Stores coding standards, architectural constraints, ongoing state. Read first every session. Without a strong CLAUDE.md, quality degrades to "generic AI-style code."
Hooks system: PostToolUse hooks automate the inner loop (auto-run eslint, prettier after every write). Prevents CI failures.
Slash commands (.claude/commands/): Automate repetitive workflows. Common: /commit-push-pr, inline bash pre-computation to gather repo state before model sees prompt.

Recommended practice (Boris Cherny, Anthropic):

Pipeline over Monolith: Spec → Draft → Simplify → Verify
Main agent coordinates sub-agents; doesn't do all work itself
Automate everything: if done 3+ times, make it a slash command
Verification non-negotiable: agent must run real test suite before shipping

Real limitations:

Context auto-compaction causes "amnesia" on architectural decisions from earlier in session
Weekly message caps: power users burn through by Wednesday running 10+ parallel sessions ($100-200/mo)
Thinking models (Opus 4.5+) are significantly slower; must manually downgrade for simple tasks
Quality depends entirely on the CLAUDE.md file; a weak one gives generic output

Claude Code vs raw API:

Feature	Claude Code (CLI)	Claude via API
Workflow	Opinionated execution-first harness	Raw, build-your-own
Tool Handling	Built-in (file ops, terminal, git)	Manual definitions required
Context	Automated (CLAUDE.md, git state)	Manual context engineering
Automation	Hooks and slash commands built-in	Must be coded from scratch
Best For	Professional daily shipping	Custom specialised agents

1.2 Cursor

Status: Described by practitioners as the leader for production AI coding and the "gold standard" for complex, high-stakes architectural work.

Key differentiators (2026):

Shadow Workspace: Runs background instance to verify AI changes actually compile and pass tests before presenting to user
Multi-Agent Judging: Second "critic" agent reviews worker agent output for architectural regressions: reduces "lazy coding" and hallucinated logic
Debug Mode v2.2: Uses runtime instrumentation to autonomously form hypotheses about bugs and fix them across the entire stack

Practitioner verdict: Preferred for production work requiring precision. Senior engineers "lead" the AI with Cursor rather than following it.

1.3 Windsurf

Status: Primary challenger to Cursor. Preferred for rapid prototyping and "vibe coding."

Key differentiators (2026):

Cascade Indexing: Proactively builds a "mental map" of the entire project. No manual @file mentions needed: it "just knows" context
Operates at 950+ tokens/sec: faster and more "magical" for building from scratch
The Cascade agent runs its own tests and terminal commands proactively

Practitioner verdict: Favoured for greenfield projects and rapid MVPs. You "collaborate with it as an equal" rather than directing it. Less precision than Cursor.

1.4 Other AI IDEs

Tool	Category	2026 Status
Trae (ByteDance)	IDE	Free with unlimited Claude access. "Solo Mode" for greenfield. Popular with solo developers.
Google Antigravity	IDE	Released Nov 2025. "Mission Control" for parallel agents. Described as "futuristic but buggy."
Void IDE	IDE	Open-source, privacy-first. Direct model connections. Go-to for FinTech/Gov regulated industries.
GitHub Copilot	IDE	Widely used in enterprises. "Issue-to-PR" automation. 20M+ activations. 10-day PR time reduced to 2.4 days.
Aider	CLI	Widely used terminal-based pair programmer. Favoured by power users for git-integrated auto-commits.
Goose (Block/Square)	Framework	Open-source agent framework. Uses MCP to connect to Slack, Jira, non-code tools.
Zed	Editor	Rust-native, high-performance. Focus on multiplayer AI coding (collaborative sessions).

1.5 Jeffrey Emanuel's Agent Flywheel

Status: Active, widely referenced as the "toolkit approach" to multi-agent orchestration.

Core idea: "Better tools → more capable agents → more code shipped." Treats agents as ephemeral workers (not persistent identities).

Key tools (14 interconnected CLI tools):

NTM (Named Tmux Manager): Rapidly spawns 5-20 terminal panes for agents
Agent Mail: "Gmail for agents": agents reserve files ("I'm working on auth.ts, don't touch") to prevent merge conflicts
bv (Beads Viewer): Graph theory (PageRank) to identify highest-priority tasks for agent assignment

Reported results: Single developer using 7 concurrent agents shipped 20,000 lines of Go code in one day.

1.6 Steve Yegge's Gas Town

Status: Active conceptual framework and orchestration system.

The eight stages of trust model:

Zero AI (manual coding)
IDE with Permissions (standard Copilot: AI suggests, human approves)
YOLO Mode (AI can run commands and edit files locally)
Wide Agent (multi-file refactors with human architectural guidance)
CLI Single (autonomous terminal agent)
CLI Multi-Agent (3-5 agents in parallel worktrees)
Agent Swarm (10+ agents coordinated by lead agent)
Gas Town (Custom Orchestrator: full "town" of specialised agents)

Gas Town roles (Mad Max themed):

Mayor: Human's chief-of-staff; primary interface for human intent
Polecats: Worker agents executing code in isolated git worktrees
Refinery: Merge coordinator handling conflicts between parallel agents
Witness/Dogs: Maintenance agents monitoring for regressions and stale branches

Key innovation over Flywheel: Polecat agents have persistent identities stored in git. If a session crashes, the agent recovers its state via git-backed hooks.

1.7 Geoffrey Huntley's Ralph pattern

Status: Widely adopted as the solution to "Context Rot": the primary failure mode of 2025.

Mechanism: "Ralph is a bash loop." Instead of one long session where the agent degrades as context fills, Ralph restarts the agent with fresh context on every iteration.

Loop: Select Task → Build Context → Execute → Detect Completion → Iterate

FIG. 01

flowchart LR
  A["Select Task"] --> B["Build Context"]
  B --> C["Execute"]
  C --> D["Detect Completion"]
  D -->|Iterate| A

Why it works: Forces durable documentation (the agent writes "tattoos", such as Beads notes and LEARNINGS.md, that survive context wipes), prevents context pollution, and keeps each task atomic.

Reported results: Used to deliver a $50K software contract for $297 in API costs.

1.8 OpenAI Codex CLI

Status: Evolved from API into full Agentic Coding Platform (GPT-5.3-Codex / "Spark").

Focuses on "System 2" reasoning for complex architectural planning
Skills system: integrates with Figma (design-to-code), Linear (task management), cloud deployment
Background automations: schedule agents to run nightly refactors or security audits
Available via npm i -g @openai/codex
Positioned as "heavy lifter" for enterprise-scale refactoring

1.9 GitHub Copilot Workspace

Status: Widely used enterprise agentic environment. 20M+ activations.

Key features:

Issue-to-PR workflow: GitHub Issue → technical plan → multi-file implementation → PR
Self-healing builds: Repair Agent automatically analyses failed builds/tests and applies fixes until passing
Multi-model support: Toggle between GPT-5.2, Claude 4.5, Gemini 3 Ultra per task

Reported metrics: PR delivery time reduced from ~10 days to 2.4 days at enterprise scale.

Part 2: practices and methods

2.1 Simon Willison's "Vibe Engineering"

Willison distinguishes "vibe engineering" (professional, accountable) from "vibe coding" (blind trust in AI).

Core principles:

Treat AI as "over-confident pair programmer": highly capable but error-prone, requires strict supervision
Strict TDD: Write tests first, confirm they fail, then have AI implement. Prevents "verification hallucinations" where AI writes tests that pass its own broken code
Strategic context management: control what enters the context window
Research phase first: Always ask for "options/approaches" before asking for implementation
Mandatory manual verification: Never outsource final correctness check to AI
"Files are memory": filesystem is primary interface for agent state, not ephemeral conversation

2.2 Addy Osmani's spec-driven development

Six core areas that must be documented for a successful AI handoff:

Commands: Exact executable commands with all flags
Testing: Framework, file locations, specific coverage expectations
Project structure: Explicit directory mapping (prevents files being created in wrong places)
Code style: Real code examples (more effective than written descriptions)
Git workflow: Branch naming, commit message format, PR requirements
Boundaries (three-tier system):
- Always Allowed: tasks agent does autonomously
- Ask First: tasks requiring human approval
- Never Touch: critical files, secrets agent must ignore

2.3 The PRP (product requirement prompt)

What it stands for: Product Requirement Prompt, the name used in Rasmus Widing's PRPs-agentic-eng repository, which defines a PRP as a PRD plus curated codebase intelligence plus an agent runbook.

What it is: An "implementation-ready specification": the bridge between a high-level PRD and actual code. Contains technical, granular details (file paths, function signatures, state management logic) that a traditional PRD lacks.

How it's used:

Created by a "Planner Agent" in collaboration with the human (3-5 iteration cycles)
Fed to an "Executor/Coder" agent as its source of truth
Defines Quality Gates (Tailwind Consistency Gate, Lighthouse Performance Gate) that agent must pass before proceeding
The human iterates on PRP before any execution code runs

2.4 Context engineering

Definition: The discipline of architecting information flow to provide an LLM with Minimum Viable Context (MVC).

Goal: Keep LLM in the "Smart Zone" (below ~40% context window usage) where reasoning is strongest.

Key techniques:

Progressive Disclosure: Load context layers as needed (Safety → Identity → Goals → Task Specs)
Sub-Agent Compression: Lightweight scout agents that find relevant patterns and return <500 token summaries instead of loading entire files
XML Delimiters: Use <context>, <constraints>, <output_format> to prevent "instruction drift"
Skeleton-of-Thought (SoT): Ask model to output file structures and function signatures first: ensures architectural alignment before logic is filled in
Output Contracts: Define exact "Success Criteria" and require a "Self-Critique" block before final output

Memory architecture (common practice in 2026):

Working Memory: Hierarchical task tracking (Epic → Task → Sub-task)
Medium-term Memory: Mandatory structured notes (COMPLETED, IN PROGRESS, BLOCKERS, KEY DECISIONS) that survive session restarts
Long-term Memory: Hybrid: Markdown files (human-readable, git-friendly) indexed by SQLite or Knowledge Graphs (Graphiti) for semantic queries

2.5 Test-driven AI development (TDAID)

TDD has become the primary guardrail for autonomous agents.

Agentic red-green-refactor:

Red: Human or Spec Agent writes failing test/behavioural assertion
Green: Coder Agent writes minimal code to pass
Refactor: Reviewer Agent optimises while keeping suite green

The "backpressure" pattern: Rather than giving instructions, developers provide tests. Agent is trapped in loop where it cannot "finish" until test suite passes. Forces convergence on working solution without human intervention.

Spec-Driven Development: Agents use SPEC.md to auto-generate integration tests before implementation: prevents "cheating" by writing tests that match incorrect code.

2.6 The BMAD Method

A comprehensive product development framework using role-based personas:

Brief: Analyst uses brainstorming to create Product Brief
Model: Architect defines technical stack, data models, coding standards
Action: Scrum Master converts architecture into "Actionable" developer stories
Development: Developer implements, QA reviews

Key innovation: "Advanced Elicitation": challenges LLM at every stage ("Red Team this architecture", "Hindsight 2020: what will we regret?") to push beyond average responses.

Warning: Many early multi-agent systems failed trying to simulate full SDLC hierarchies (Analyst/PM/Developer personas). This creates massive coordination friction. Successful systems use operational roles (Mayor/Polecat) rather than SDLC personas.

2.7 Multi-model ideation

Practitioners use different models for their specific "reasoning flavours":

Stage	Preferred Model	Why
Exploration/Brainstorming	GPT-4o/5	Wide-ranging brainstorming, "Mary-style" elicitation
Implementation	Claude 3.5 Sonnet/4	Superior architectural adherence, high-fidelity coding
Validation/Research	Gemini 1.5 Pro/2	Long-context analysis of entire libraries/codebases

Workflow: Generate Brief in one model → Refine architecture in another → Execute in third → Pass distilled PRP context between them.

Part 3: multi-agent orchestration

3.1 The schools of thought

School 1: Agent Flywheel (toolkit approach)

Agents are ephemeral workers assigned tasks from a shared queue
Human "Orchestrator" uses tools (NTM, Beads, Agent Mail) to manage efficiently
Better for: teams with strong task decomposition discipline

School 2: Gas Town (orchestrator approach)

Agents have persistent identities with git-backed state
Mayor agent interprets human intent and assigns Polecats
Refinery handles merge coordination
Better for: complex, long-running projects where state continuity matters

School 3: Ralph pattern (continuous loop)

Agents are stateless workers in a bash loop
Fresh context every iteration; state preserved in external files
Better for: cost control and preventing context rot on long tasks

3.2 Coordination mechanisms that work

Git worktrees (standard practice in 2026):

Every agent gets its own directory (./wt-feature-auth, ./wt-api-fix)
Prevents agents from overwriting each other's files in real-time
Enables easy "diff between agents" review

Beads (graph-based shared memory):

Stored as files in .beads/: agents can read entire project's task dependencies
Agents self-assign work that isn't blocked by others
PageRank algorithm identifies which tasks to do first

Agent-to-agent messaging (Agent Mail MCP):

Agents send "memos" to each other
When Agent A modifies shared library, it "emails" Agent B
Agent B checks mailbox at start of next loop iteration

The "backpressure" pattern:

Tests as instructions rather than verbal descriptions
Agent cannot "finish" until test suite passes
Forces convergence without human intervention

3.3 Real failure modes and limitations

Failure Mode	Description	Solution
Context Rot	Agent degrades as context window fills over long sessions	Ralph Pattern: fresh context per task
Context Compaction Loss	Critical reasoning is lost when agent summarises for next session	Structured notes + external state files
"BMAD" Trap	SDLC persona hierarchies create coordination friction	Use operational roles (Mayor/Polecat) not job roles
Optimistic Exit	Agents say "I'm done!" when they've actually given up	Dual-condition exit gates: explicit EXIT_SIGNAL + test pass + Witness agent approval
Token Burn	Running 20+ agents costs $100+/hour	Revert to 3-5 high-quality agents; avoid swarms
Merge Conflicts	Parallel agents clash on shared files	Agent Mail file reservations + Refinery agent for merges

3.4 What works versus what is marketed

Real and working:

Git worktrees for agent isolation (universal adoption)
3-5 agent limit for cost/quality ratio
Test-as-backpressure for autonomous completion
CLAUDE.md/AGENTS.md as "project memory"
Fresh context loops (Ralph) for preventing context rot
Agent Mail for async file reservation

Overhyped or failed:

"Agent Swarms" of 20+ agents: cost prohibitive, coordination overhead too high
Pure no-code / "coding is dead" narrative: architecting is the new coding, not eliminating it
Million-token context windows replacing RAG: smart indexing still beats brute force
Weeks-long autonomous agent runs: context rot makes this impractical

Part 4: a typical vibe engineering workflow

4.1 Complete workflow (end to end)

Phase 1: planning (context engineering)

Human defines high-level goal
Planner Agent produces initial technical spec (PRP draft)
Human iterates on PRP 3-5 cycles, challenging assumptions ("Red Team this", "What will we regret?")
PRP defines: file paths, function signatures, Quality Gates, Three-Tier Boundaries
Human approves PRP before ANY execution begins
Context seeded: human decides which 5% of codebase agents actually need to see

Phase 2: implementation (agent execution)

Orchestrator assigns tasks from Beads queue to workers
Each worker spawned in isolated git worktree
Ralph Loop: agent wakes up, reads state files (Beads notes, LEARNINGS.md), executes one atomic task, writes learnings, session ends
Agents communicate via Agent Mail for shared file coordination
Tests act as backpressure: agent loops until suite passes

Phase 3: review and testing (taste plus automation)

~90% of review automated via Quality Gates defined in PRP
- Similarity gates: new code matches existing patterns
- Security scanning (AI code has ~23.7% higher security debt)
- Performance gates (Lighthouse scores, etc.)
Human called in for "Ambiguity Escalations" and "Taste Checkpoints"
Refinery agent handles merge coordination between parallel workstreams
Human performs final architectural review and "vibe audit" (does it feel generic or distinctive?)

4.2 The 30-minute rule

Tasks taking an agent more than 30 minutes = "under-decomposed."

Senior engineer value in 2026 is measured by ability to decompose a vision into 50 perfectly-contextualised 30-minute atomic tasks that run in parallel.

4.3 Industry statistics (early 2026)

Metric	Reality
AI-generated code at top companies	30-50% (Google: 30%+, Meta: ~50%, Microsoft: ~33%)
Global production code AI-assisted	41-46%
Time senior engineers spend manually coding	~15%
Time spent on architecture, security, context	~85% (the "300% more time" shift)
Optimal human-to-agent ratio	1 human : 8-12 parallel agent streams

4.4 What senior engineers still do by hand

Context Seeding: Deciding which 5% of codebase agents need to see
Constraint Mapping: Identifying "dead ends" AI will fall into and blocking them in PRP
Conflict Resolution: Merging parallel workstreams when agent logic clashes at system level
Taste/Vibe Audit: Ensuring final product doesn't feel "AI-generic" and carries a human brand
Architecture Definition: High-level system design and tech stack decisions
Security Review: AI-generated code has statistically higher security debt