This itinerary is for engineers and tech leads who are already building with AI agents and want to reason from first principles about how to scale agentic development across teams and codebases.
The central thesis: agentic engineering is an alignment problem. Alignment means how close the agent’s actions and outputs stay to human expectations and intent. Every design decision becomes a question of alignment as output scales beyond what any human can review line by line.
Principle I: Agentic Time >>> Human Time
Agentic code cost tends to zero. Human attention does not. The optimal agentic workflow may look wildly different from traditional software engineering.
When an agent stalls or produces partial output, don’t step in — push the agent to continue with accumulated context.
- What Are Agents?
- Workflows vs. Agents
- Ralph Technique — the push loop that combats lazy completion
- Orchestrator-Worker
Principle II: Misalignment & Feedback Loops
Intelligence is contextual: an agent without tooling is fragile, an agent with linting, testing, and type checking is self-correcting. But not everything is deterministically testable. Give agents an explicit escape hatch to pause and ask.
- Human-in-the-Loop — the HITL tool that changes the action space
- Evaluator-Optimizer
- Reflection
Principle III: Chaotic Oscillators
Agentic errors compound through context contamination and refactor avoidance. Agents find shortcuts that satisfy tests while missing intent. Monitor the reasoning process, not just the output.
- Reward Hacking — the central failure mode
- Hawk Agent — cross-provider process-level oversight
- Parallelization
Principle IV: Memetic Virus
Context is not neutral. Bad patterns in the codebase propagate through every agent session that touches them. When a direction fails, don’t fix forward — extract learnings, rollback, restart clean.
- Rollback and Learnings — recovery when the cost of failure approaches zero
- Iterative Refinement
- Plan-and-Execute
Principle V: The Review Bottleneck
Agent output grows non-stop; reviewer time stays constant. Pull requests as designed will not survive agentic scale. New patterns: surprise-driven triage, artifact-based review, agent timelines. New teams: stronger ownership, agent-first interfaces, faster infrastructure.
- Agentic Code Review — review patterns for agentic scale
- Agent-First Teams — how organizations restructure
- Handoffs
- Composite Patterns
Outcome
At the end of this itinerary you should be able to design an agentic engineering workflow for a team: feedback loops, oversight patterns, review processes, and the organizational changes required to make it work at scale.