Mastering AI Agents: The Builder's Deep Dive

~12 min read

February 2026. Jack Dorsey cuts Block in half.

Block goes from 12,500 employees to roughly 6,000. Stock surges 24%. Q4 gross profit is up 24% year-over-year to $2.87 billion. The market didn’t punish the layoff. It rewarded it.

If you’re an engineer reading that headline, the obvious takeaway is: we’re next.

That’s the wrong takeaway. But the right one requires looking at more data than a single headline. Let’s do that.

The data that says yes, be worried

Some of this is real. Don’t let anyone tell you it isn’t.

• Stanford Digital Economy Lab (2025): Employment for software developers aged 22-25 declined nearly 20% from their late-2022 peak by July 2025. Workers in the most AI-exposed occupations saw a 16% relative employment decline compared to least AI-exposed roles.

• Entry-level pipeline: Estimates range from 50-73% drops in certain junior hiring segments. The “write CRUD for 2 years then get promoted” career ladder is collapsing.

• Indeed’s SWE posting index: Peaked at ~230 (indexed to Feb 2020) during the cheap-capital hiring frenzy. Currently ~70. That 2021-2022 spike was a bubble, not a baseline.

The work being automated: boilerplate code, routine CRUD, basic test generation, documentation, simple refactors. If your job is 80% this, the threat is real.

The data that says no, you’re reading it wrong

• Bureau of Labor Statistics (2024): Software developers projected to grow 15% from 2024-2034 — “much faster than average.” 287,900 new jobs expected. Median pay: $131,450.

• Bitkom, Germany (2025): 855 companies surveyed. 109,000 unfilled IT positions. 42% anticipate needing

  additional IT specialists specifically because of AI adoption.

• a16z (Steven Sinofsky, Feb 2026): “There will be more software than ever before. We are nowhere near meeting the demand for what software can do.”

How can both be true? Jobs disappearing AND jobs growing? There’s a framework that explains this perfectly.

The Jevons Paradox

1865. James Watt’s steam engine makes coal dramatically more efficient. Everyone expects coal consumption to drop. The opposite happens — efficiency made coal-powered industry viable in thousands of new applications. Total consumption exploded.

The pattern repeats everywhere: cheaper transistors → more transistors in everything. Cheaper bandwidth → streaming video, TikTok. Every efficiency gain expanded the total surface area of the market.

Applied to 2026: AI makes software 2-10x cheaper to build. Companies won’t build the same amount with fewer engineers. They’ll build software they never could have justified before. Internal tools that required 5 engineers for 6 months now get prototyped in a week. The “things worth building” surface area has expanded by an order of magnitude.

This explains the Block story. Dorsey didn’t prove engineering is worthless. He proved per-engineer productivity increased enough that the same output requires fewer people. But the total demand for software — across all companies, all industries — is exploding.

The Anthropic contradiction

January 2026, Davos. Anthropic’s CEO Dario Amodei tells the audience that AI could handle “most, maybe all” of software engineering work within 6-12 months. He adds: “I have engineers within Anthropic who say, I don’t write any code anymore. I just let the model write the code.”

The same week, Anthropic’s careers page: 448 open roles. 146 in software engineering. Plans to double headcount to 2,000+.

Read that again. The CEO of the company building the AI says engineers are being replaced. His HR department is hiring 146 more of them.

What’s actually happening: writing code got automated. Engineering judgment became the job — and became more valuable.

What the job actually looks like now

Naval Ravikant puts it well: software engineers think in code. They understand what happens underneath the abstractions. All abstractions are leaky. When AI produces buggy, suboptimal, architecturally broken code, the person who understands the substrate catches failures everyone else misses.

That skill didn’t become less valuable when AI started writing code. It became the bottleneck.

Here’s what hiring managers screen for in 2026:

1. Can you find problems independently — without a manager writing the spec?

2. Can you connect dots across business context — understanding WHY a feature matters, not just HOW to build it?

3. Can you direct AI to build the solution — Claude Code, Cursor, or equivalent?

4. Can you verify what AI produces — catching bugs, evaluating architecture, identifying risks?

This is the job. It’s a better job than what it replaced. And it’s what this course teaches.

References

• Stanford Digital Economy Lab (2025) — AI and junior developer employment decline. Via StackOverflow Blog.

• Bureau of Labor Statistics (2024) — Software Developers outlook 2024-2034. bls.gov/ooh

• Dario Amodei, Davos, Jan 2026 — AI could handle “most, maybe all” of SWE work. Via Entrepreneur.com

• Jack Dorsey / Block layoffs, Feb 2026 — 12,500 to ~6,000 employees, Q4 gross profit up 24%. Via TechCrunch

• Steven Sinofsky / a16z, Feb 2026 — “There will be more software than ever before.” a16z.com

• Bitkom, Germany (2025) — 855 companies surveyed, 42% need more IT specialists due to AI. silicon-saxony.de

• Naval Ravikant — Software engineers as leveraged people, leaky abstractions argument.

• Turing College (March 2026) — Jevons Paradox applied to SWE market, Indeed posting index analysis. turingcollege.com

~12 min read

Karpathy named it. Then he named its replacement.

February 2025. Andrej Karpathy tweets: “A new kind of coding where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.” He was describing throwaway weekend projects. Collins Dictionary named it Word of the Year. The container escaped immediately.

Exactly one year later, February 2026, Karpathy posts again. This time the word is “agentic engineering.” His framing: “‘Agentic’ because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight. ‘Engineering’ to emphasize that there is an art and science and expertise to it.”

That’s the arc of this course in two tweets. Vibe coding is the starting point. Agentic engineering is the destination. This lesson is about the ceiling between them.

Where vibe coding legitimately works

Credit where it’s due. Vibe coding is genuinely powerful for:

• Greenfield prototypes and hackathon demos — you need something running by Sunday, quality is noise

• Personal scripts — if it breaks, you regenerate it

• Learning and exploration — newcomers build things they couldn’t otherwise

• Creative brainstorming — over-generate on purpose, throw everything away, build properly

If your project fits these criteria, vibe coding is the fastest path. No shame in it. The problem is when the same posture carries over into production systems, team codebases, and paying customers.

The 80% problem

Sourcegraph published research in May 2026 that quantified what most of us already felt:

Coding agents reliably complete the visible 80% of a task. They silently miss the 20% that lives outside their context window.

That missed 20% is consistent: auth middleware wrapping the changed function, API DTOs serialized at a different layer, audit logs recording state transitions, integration tests in a sibling repo, frontend guards mirroring backend permissions, migration scripts that need regenerating.

The agent doesn’t know these exist. It completed the task. It looks done. You ship it. The bug surfaces in production three days later.

In Sourcegraph’s data, 84% of large enterprise accounts saw a steady increase in lines of code after AI rollout. Agents generate more code, which creates more need for engineers who can understand it.

When it fails at scale: the Amazon story

Q3 2025. Amazon orders a 90-day reset on its code deployment controls after a string of incidents, at least one tied to Amazon’s AI coding assistant Q. Amazon SVP Dave Treadwell described “high blast radius changes” — software updates that propagated broadly because control planes lacked safeguards.

Vibe coding didn’t cause the problem. Skipping the design thinking did. The AI wrote functional code. Nobody verified whether functional code was safe code.

Skill atrophy: the quiet crisis

Addy Osmani at Google, February 2026: “Developers who lean on AI before building fundamentals can produce code without understanding it, ship features without learning why the patterns exist.”

This is the most insidious failure mode. You skip the struggle that builds understanding. You never sit with a tricky bug for 2 hours and finally grasp the event loop. You never manually implement retry and learn why exponential backoff matters. You got the answer without doing the work.

Six months of vibe coding can produce an impressive portfolio and zero growth in engineering capability.

Pause and think: If you removed all AI tools from your workflow tomorrow, could you still do your job? If not, you haven’t been learning — you’ve been outsourcing.

Signs you’ve hit the ceiling

Read this list honestly:

• You accept diffs without reading them and later can’t explain what the code does

• You’ve shipped bugs that were obvious in the diff but you never looked

• You can prototype anything but struggle to maintain, extend, or debug what you’ve built

• You describe your codebase to others and realize you don’t fully understand it yourself

• You feel like the AI is driving and you’re just along for the ride

This isn’t a moral failing. It’s a natural stopping point. The question is what’s on the other side.

The posture difference

Vibe coding posture: passive recipient. Trust the model. Ship if it runs.

Agentic engineering posture: active orchestrator. You own correctness. You evaluate the output. You intervene when the agent drifts.

The tools are often identical. Claude Code is Claude Code. The difference is not the tool — it’s the professional discipline the person using it brings.

Simon Willison nailed it: “It has been fascinating to watch how so many of the techniques associated with high-quality software engineering — automated tests and linting and clear documentation and CI and CD and cleanly factored code — turn out to help coding agents produce better results as well.”

Good engineering practices don’t just help you. They help your agents. The vibe coder who wants to break through the ceiling doesn’t need new tools. They need the discipline.

References

• Andrej Karpathy — Vibe coding tweet (Feb 2, 2025). Agentic engineering thread (Feb 4, 2026). x.com/karpathy

• Collins Dictionary — “Vibe coding” named Word of the Year 2025. blog.collinsdictionary.com

• Sourcegraph (May 2026) — “Agentic Coding in 2026.” The 80% problem, 84% LOC increase. sourcegraph.com/blog/agentic-coding

• Amazon 90-day deployment reset (Q3 2025) — High blast radius changes from AI-assisted code. Via Sourcegraph.

• Addy Osmani, Google (Feb 2026) — Skill atrophy in AI-assisted development. addyosmani.com/blog/agentic-engineering

• Simon Willison (March 2026) — Good engineering practices help agents. simonwillison.net

• Turing College (March 2026) — Agentic engineering vs vibe coding taxonomy. turingcollege.com

~10 min read

Two interview answers. One gets the job.

Before this course: “I use AI tools to write code faster. I’m really productive with Claude Code and Cursor.”

After this course: “I designed a context management system that reduced token spend 60% while maintaining the same task completion rate. I identified that tool results were being loaded upfront and switched to JIT loading. Here’s the architecture.”

Same person. Same tools. The difference is understanding the system well enough to explain and improve it. That conversation doesn’t happen by accident. It happens because you built the system with enough understanding to articulate the trade-offs.

Same for architecture reviews. Before: “Let’s use LangGraph for this” (because someone mentioned it). After: “I evaluated 5 frameworks against our six pillars. LangGraph won on agent loop and context engineering. CrewAI was faster to prototype but weaker on memory. Here’s the trade-off.”

Evaluation fluency over framework familiarity. That’s the senior engineer posture.

The two-skill stack that cannot lose

Software engineering fundamentals — data structures, system design, networking, databases, testing. The substrate. The thing that lets you know what’s happening when the abstraction leaks.

AI engineering fluency — agentic workflows, context engineering, tool design, evaluation. The force multiplier.

The combination is what every market signal is screaming for. Not one or the other — both. The engineer who understands system design AND can architect an agent system occupies a niche that barely existed 18 months ago and is expanding faster than any other in tech.

The real stakes: 1.5x-10x

Companies spend $20-100+ per developer per month on AI tools. Enterprise teams spend thousands monthly on API tokens. Every AI token is a line item on someone’s budget.

The implicit contract in 2026: if we give you a 10x multiplier, we expect measurably more output. Engineering managers report expecting 1.5x-10x improvement from their teams. That’s the floor, not the ceiling.

The engineer who can’t demonstrate the lift is having an uncomfortable conversation with their manager within 12 months. The engineer who can explain how they’re getting that lift — because they understand the systems underneath — is getting promoted.

Where you are now

Most readers entering this course:

• Already shipping with Claude Code or Cursor daily

• Producing useful output but accepting diffs without fully understanding them

• Strong gut feel about what works but no systematic framework for WHY

• Nervous about whether this is enough for where the industry is going

What completing this course changes

• You can explain every architectural decision you make — to yourself, teammates, a hiring manager

• You have a six-pillar framework to evaluate any new tool, agent, or paper in minutes

• You can talk about context-cost trade-offs, not just “I used Claude Code”

• You can design agent architecture from scratch — loops, tools, memory, permissions, evaluation

• You have the vocabulary to position yourself correctly in a job market that rewards specificity

Who this is for

• Experienced engineer anxious about AI. You have system thinking skills. Just need the AI-specific knowledge layer on top.

• Vibe coder wanting real depth. You have AI intuition. Need the engineering foundation underneath.

• Founder building AI products. Need enough understanding to make architecture decisions and evaluate your team’s work.

• Company wants you to build an agent. Go end-to-end or skip to the chapters you need. The capstone guides you through the actual system design.

Who this is NOT for

• Complete beginners who haven’t shipped with any AI coding tool — the prerequisite is real usage

• People who want a recipe without understanding why — this course explains the why, and the why IS the product

• Framework tutorial seekers — frameworks come and go. The six pillars don’t.

The course ahead

Eleven chapters. Six pillars. From the inside out:

1. Cognitive Calibration — The mental model. Six Pillars. Just enough LLM mechanics.

2. Agent Loop — Think-act-observe. Streaming, retry, loop detection.

3. Tool System — Function calling, dynamic loading, permissions, MCP.

4. Context Engineering — The deepest chapter. The real moat.

5. Memory — Cross-session persistence and failure modes.

6. Multi-Agent — Context isolation, not role-playing.

7. Evaluation — How to know your agent works.

8. Cost & Latency — Making it affordable and fast.

9. Harness Engineering — Observability, deployment, security.

10. Frameworks — Evaluate any framework through six pillars.

11. Capstone — Design your own agent architecture.

Every lesson starts with a real problem. You think before we reveal the answer. By the end, you don’t just know the concepts — you’ve built the judgment to apply them.

Let’s start. Chapter 1 gives you the framework you’ll use for everything else.

References

• Turing College (March 2026) — 1.5x-10x output expectations, $20-100+/dev/month AI tool spend. turingcollege.com/blog/will-ai-replace-software-engineers

• Andrej Karpathy (Feb 2026) — Agentic engineering thread. x.com/karpathy/status/2019137879310836075

• Naval Ravikant — Software engineers as leveraged people, leaky abstractions argument.

• Anthropic engineering blog — Context management and token optimization patterns.