No Vibes Allowed — Solving Hard Problems in Complex Codebases

Dex opens with a stark finding from a 100K-developer study: teams using AI coding assistants are shipping more code — but a disproportionate amount of it is rework. The net productivity gain is far smaller than the raw output suggests.

The core distinction:

• Greenfield — AI excels when there's no existing context to respect. Start from scratch and go fast.
• Brownfield — AI struggles with existing codebases, established patterns, implicit conventions, and complex dependency graphs. This is where most real work happens.

The talk's premise: vibe coding doesn't scale to complex codebases. You need structure, discipline, and deliberate context management to get expert-quality results from AI.

Dex describes his team's journey: 8 weeks of structured experimentation with a 3-person team at HumanLayer. They went from skeptics to believers after systematically testing workflows.

The breakthrough came from treating AI coding as a context engineering problem, not a prompting problem. The key workflow:

1. Research — Explore the codebase, gather relevant context, understand patterns
2. Plan — Convert research into a concrete, step-by-step implementation plan
3. Implement — Execute the plan with a fresh, focused context window

This isn't about clever prompts — it's about workflow architecture. Each phase has different context needs and different failure modes.

Dex lays out a maturity model for context engineering, showing how teams evolve their approach:

Dex introduces four optimization axes for context engineering:

• Relevance — Is the context actually useful for this specific task?
• Recency — Is the context fresh, or has the codebase evolved past it?
• Density — Is the signal-to-noise ratio high enough?
• Coherence — Does the context tell a consistent story, or does it contradict itself?

One of the talk's most memorable concepts. When the context window fills up with noise — previous errors, irrelevant code, contradictory instructions — the model enters what Dex calls the "Dumb Zone".

Signs you're in the dumb zone:

• Model starts ignoring instructions that are clearly in the prompt
• Outputs become internally contradictory
• The model hallucinates APIs, function signatures, or file paths
• Fixes for one issue break previously working code
• The model starts apologizing and rewriting the same code in loops

The antidote: don't let it happen. Compact context proactively. Start fresh windows. The Research→Plan→Implement workflow is specifically designed to avoid the dumb zone by keeping each phase's context window clean and focused.

The research phase uses sub-agents to explore the codebase without polluting the main context window. This is the critical insight: exploration is messy, but its output doesn't have to be.

How it works:

1. Spawn sub-agents to search the codebase, read files, trace dependencies
2. Each sub-agent explores a specific question or area
3. Sub-agents produce a structured research document summarizing findings
4. The research document — not the raw exploration — feeds into the next phase

The output is a clean research document covering: relevant files, existing patterns, API contracts, edge cases discovered, and open questions. This becomes the foundation for the plan.

The plan phase converts the research document into an actionable implementation plan. This is where human judgment is most valuable.

Key properties of a good plan:

• Step-by-step instructions the implementing agent can follow linearly
• Code snippets embedded as anchors — showing exact patterns to follow
• Explicit listing of files to modify and in what order
• Expected behavior at each step (verification points)

Plans with embedded code snippets outperform purely prose plans because they give the implementing agent concrete anchors to pattern-match against, reducing hallucination of APIs and coding patterns.

Implementation starts with a fresh context window containing only the plan and necessary reference code. No research noise. No exploration dead ends.

The implementing agent:

• Receives the plan document as its primary context
• Uses code snippets from the plan as anchoring examples
• Follows steps linearly, checking off each one
• Has maximum context budget available for actual implementation

This is where the "no vibes" philosophy pays off: the implementation isn't hoping the model guesses right — it's executing a verified plan with the right context.

A counterintuitive lesson: don't dump everything at once. When onboarding AI to a codebase, progressive disclosure outperforms comprehensive context.

The analogy: onboarding a new engineer. You don't hand them the entire codebase on day one. You progressively introduce:

1. Architecture overview — high-level structure, key abstractions
2. Local patterns — conventions in the specific area they'll work on
3. Relevant examples — similar changes that were made previously
4. Edge cases — only the ones relevant to the current task

This principle applies to both single-session work and multi-session projects. Each new task should start with a fresh, progressively-built context rather than carrying forward everything from previous sessions.

Even with structured workflows, agents sometimes go down the wrong path. Dex discusses how to detect and recover from trajectory traps.

Early detection signals:

• Agent starts modifying files not in the plan
• Diff size grows beyond what the task warrants
• Agent introduces new abstractions not discussed in the plan
• Multiple consecutive error-fix cycles on the same file

Recovery strategies:

• Detect early — Monitor the agent's trajectory, don't wait for a final broken result
• Compact — Summarize what was learned from the failed attempt
• Restart — Fresh context window with the original plan + lessons from the failure

After 8 weeks of applying these techniques, the 3-person HumanLayer team measured concrete results:

• 2–3× throughput — Measured in shipped features, not lines of code
• No slop — Code quality maintained at expert level, no increase in rework
• Expert-quality code — AI-generated code follows existing patterns and conventions

The workflow transforms the developer role: less time typing, more time thinking, designing, and validating. The AI handles execution; humans handle judgment.