Why Coding Agents Fail in Real Codebases: First Principles for Senior Engineers
Dan Gittik
Software engineering for the age of AI
Software engineering assumes humans read and write code. What if they don’t?
Most AI courses fall into two camps: vibe coding for newcomers, and tutorials on particular methods, like Eval or RAG. Some are great—but as a senior engineer, they don’t address the problems I deal with routinely: keeping up with the volume of AI code, knowing when it’s almost right, and deciding how far to trust an agent.
I don’t have a quick fix; frankly, I don’t think one exists.
Instead, I see these problems as symptoms of a deeper cause. Our mental models, processes and tools were developed over the last 50 years around an implicit assumption: that code is read and written by humans. That assumption permeates our engineering practices and design patterns—and is no longer reliably true.
In this three-hour workshop, we’ll reframe software engineering from first principles, accounting for AI’s strengths and weaknesses. Beyond managing our agents better, we’ll ask how to manage complexity with them: when to trust them, when to stop them, and how to articulate our judgement so they can act on it.
You’ll apply this outlook to your own codebase, then we’ll reconvene two weeks later to compare notes.
What you’ll learn
Rethink software engineering from first principles to manage complexity with coding agents in your own codebase.
Examine the three properties behind nearly every agent failure you’ve seen.
Use real transcripts and demos to reason about failures beyond an agent’s own explanations.
Develop a vocabulary for tracing practical problems to their underlying causes.
Move knowledge out of heads and emails into maps, ledgers and lints that teach.
Reconsider CLIs and other interfaces built around human affordances.
Design AI-first tools for agents acting on your behalf.
Explore which formats, abstractions and patterns agents seem to prefer.
Revisit DRY: agents don’t mind repetition when they have a clear map or verification engine.
Reconsider code review when agents produce a month’s worth of code in a day: how do you home in on what’s “almost right”?
Explore what changes when you can implement and compare alternatives instead of debating them.
Understand the verifier precondition that determines when many cheap attempts beat one careful one.
Understand why AI critics can’t reliably decide that something is good enough.
Explore how to impose stopping criteria from outside the agent.
Reason about when an agent should consult you, when to trust it, and how to recognize over-engineering.
Reconsider what remains durably ours as agents take over more of the coding.
Recognize where agents are good enough—or superior—and focus your judgement where it matters.
Apply this outlook to your own codebase, then compare what worked in the feedback session two weeks later.
Workshop agenda
The problem with AI, and why we’re probably looking at it all wrong
Why familiar approaches struggle with AI, and what changes when we drop the assumption that code is read and written by humans.
Understanding agents: from properties to practices
Dynamic demos, real transcripts and the reasoning underneath: from agent properties to knowledge artifacts, AI-first tools, code structure, parallel attempts and verification.
Understanding ourselves: new horizons in a changing profession
Reconsider our role as agents take over more of the coding: what remains durably ours, where agents are good enough or superior, and how to articulate human judgement.
Consolidation: managing complexity with AI and some implied solutions
Bring the ideas together to revisit code review, trust, over-engineering and stopping criteria—and reason about managing complexity with agents.
Your challenge
Leave with open-ended questions to apply to your own codebase over the next two weeks. Choose what is relevant to your context and bring your findings to the followup session.
Q&A
Questions and discussion about the ideas, demos and their relevance to your own engineering context.
Two weeks later: followup session
A live discussion of submitted challenges: compare which methods proved relevant in your projects, what worked, what didn’t, and why.
Learn directly from Dan
Dan Gittik
Engineer & teacher · Ex-Google & Magic Leap · 15+ years · 50,000+ learners
Who this workshop is for
Senior engineers and tech leads who already work with coding agents and have outgrown prompt tips
Engineers responsible for large or long-lived codebases that AI struggles to handle
PMs and managers looking to understand what software engineering might look like in the age of AI, and who don’t mind a technical discussion
What's included
Live sessions
Learn directly from Dan Gittik in a real-time, interactive format.
3-hour live workshop
Demos, real transcripts, discussion and Q&A.
Two-week practical challenge
Apply the ideas to their own codebase.
1-hour follow-up session
Discuss submitted challenges and compare what worked.
Lifetime access
Go back to course content and recordings whenever you need to.
Certificate of completion
Provided through Maven.
Maven Guarantee
Your purchase is backed by the Maven Guarantee.
Frequently asked questions
Maven for Teams
Reimbursement
Get your company to pay
Everything L&D needs: email template, receipts, and certificate of completion.
Get reimbursedTeam discount
Learn with your teammates
Save 20%+ when 2 or more teammates enroll in the same cohort.
Save 20%+ with a teamPrivate cohort
Run a cohort for your org
A dedicated cohort with a custom schedule and curriculum, tailored to your team.
Book a private cohort$499
USD
1–4pm EST