Vibe Engines
YouTube
LEARNING PATH · AI Engineering

Adapt to the AI Era

For engineers who want to get more valuable as AI makes code cheap.

Intermediate ~3h 45m9 lessons11 steps

The role-agnostic adaptation arc: understand the shift, learn to direct and review AI, build the new stack (spec-driven development, evals, reviewing AI code), then present and price the judgment that becomes your moat. A 90-day plan you can actually track.

  • Read the capability trend and what it means for your role
  • Direct AI as a fast junior — and review its output adversarially
  • Build with spec-driven development and design an eval for AI output
  • Present AI-era work and negotiate the skills premium
0 / 9 done · 0%
  1. ToolTool · optional

    Agent Time-Horizon Explorer

    Days 1–20 — see the trend you’re adapting to: how fast agent capability is growing.

  2. HandbookNext up

    The AI-Era Backend Engineer

    The role shift in depth (swap in your own: frontend, data, devops, QA, or EM).

  3. Handbook

    The Agentic Coding Handbook

    Days 20–60 — work AI-augmented: the agentic coding workflow.

  4. Handbook

    Vibe Coding vs Spec-Driven Development

    The build discipline: specify and verify, don’t just vibe.

  5. Handbook

    The Context Engineering Handbook

    The core skill — directing what the model sees.

  6. Challenge

    Spot the Bug in AI Code

    Practice the new core skill: reviewing AI code adversarially.

  7. Challenge

    Write a Verifier

    Design a verifier — the mindset behind evals.

  8. Handbook

    AI-Assisted Interviews

    Days 60–90 — the 2026 interview: working with AI in the room.

  9. Handbook

    The Resume & Portfolio Handbook

    Present AI-era work — a portfolio of judgment.

  10. Handbook

    The Salary Negotiation Handbook

    Capture the AI-skills premium with a data-anchored ask.

  11. ToolTool · optional

    AI Salary Explorer

    Calibrate the band before you negotiate.

How this path works

This path is for working engineers in any role, whether backend, frontend, data, DevOps, QA or engineering management, who have noticed that producing plausible code, config and tests has become cheap. It does not ask you to change careers. It asks which parts of your job were the typing and which were the judgment, and how to spend your next ninety days on the second kind.

What the AI-era version of an engineering job rewards is fairly specific. You are expected to direct a coding agent with a clear specification, review what it produces as skeptically as you would a new hire's pull request, and build the checks that tell you whether AI-generated output is right. Interviews are starting to test the same things, and so are promotion conversations.

The order mirrors the three phases named in the step notes. Days 1 to 20 are orientation: the capability trend and the shift in your own role. Days 20 to 60 are craft: agentic coding, spec-driven development, context engineering, and two exercises in adversarial review and verifier design. Days 60 to 90 are presentation: the AI-assisted interview, a portfolio built around judgment, and the negotiation that follows. You can do the phases in parallel with a job, because every step is a single sitting.

What each step gives you

  1. Agent Time-Horizon Explorer

    An adjustable projection of how long a task AI agents can complete reliably, extrapolated from a doubling trend. You set today's horizon and the doubling period, then see the calendar dates when day-long and week-long tasks come into range. It prepares you to answer the planning question every team now faces: which of your tasks are safe to delegate this year, and which will be next?

  2. The AI-Era Backend Engineer

    A career handbook on what gets cheaper and what gets scarce for backend engineers, with a new stack to build a moat on: reviewing AI code like a senior, spec-driven development, and LLM features with evals, cost and latency in mind. It ends with five things to try this week and a ninety-day plan. Read the version for your own role if you are not on the backend.

  3. The Agentic Coding Handbook

    How coding agents actually work: a loop, a context window and a set of tools. It covers the instruction file as your highest-leverage artifact, the plan-then-verify workflow, and scaling up with skills, subagents and hooks. After it you can answer how you would set up a repository for an agent, and why small verified steps beat one giant diff.

  4. Vibe Coding vs Spec-Driven Development

    Two ways of building with AI, compared head to head: conversational vibe coding, and spec-driven development with its loop of spec, plan, tasks and implementation. A worked scenario takes a prototype to production. It prepares you for the judgment call you will make weekly, which is when a throwaway prompt is fine and when you need a written spec first.

  5. The Context Engineering Handbook

    Context engineering is curating everything the model sees: system prompt, tools, retrieved knowledge, history and memory. This page explains why adding more context often hurts, introduces four operations for managing the window, and ends with a budget-packing exercise. Use it to diagnose an agent that forgets earlier instructions or gets slow and expensive on long tasks.

  6. Spot the Bug in AI Code

    An assistant wrote a history-trimmer to fit a chat into the context window. It looks right, type-checks and passes the obvious case, and your job is to find what it gets wrong and fix it against hidden tests. This is a direct rehearsal of reviewing AI-written code, and of the review tasks that now appear in AI-assisted interviews.

  7. Write a Verifier

    You write a verifier, the function that decides whether an answer is correct, and the page makes the case that a gameable verifier is worse than none. Hidden tests probe for loopholes. It trains the mindset behind every eval and automated check, and prepares you for questions such as how you would know a model's output is right without reading it.

  8. AI-Assisted Interviews

    The interview format has flipped from banning AI to expecting it, so what gets scored shifts from writing code to working with the assistant. The handbook covers the new rounds, the reasoning for why review matters more than generation, and how to prepare. Practice here for the round where you are handed a generated solution and asked to critique it.

  9. The Resume & Portfolio Handbook

    Why an applicant tracking system scores keyword coverage before a person reads you, how to clear that filter, and how to win the human reader afterward. It includes a section on presenting AI-era work. Use it to rewrite your résumé around decisions you made and results you verified, rather than a list of tools you have touched.

  10. The Salary Negotiation Handbook

    The arithmetic of why countering an offer is almost always worth it, how your alternatives set your leverage, and how a small difference compounds over years. It then walks through how to actually ask and which pitfalls to avoid. It prepares you for the recruiter call where you are asked about expectations, including how to talk about AI skills as a reason for the number.

  11. AI Salary Explorer

    Indicative total-compensation ranges for AI and ML engineer, research engineer, applied scientist and software roles by level and company tier, built on an open multiplier model. Treat the output as orientation, not advice. Use it before a negotiation to sanity-check a range, and to see how much level and company tier move the figure compared with your own skills.

A study plan

  1. Days 1–20

    Orient. Use the Agent Time-Horizon Explorer with your own task list, then read the AI-Era handbook for your role and write down three tasks you would delegate and three you would not. Keep the list; you will revisit it at day 90.

  2. Days 21–40

    Adopt a real workflow. Read Agentic Coding and Vibe Coding versus Spec-Driven Development, then ship one small feature at work with a written spec, a plan, and an agent doing the implementation in verified steps. Keep notes on where it went wrong.

  3. Days 41–60

    Build the trust skills. Read Context Engineering, then solve Spot the Bug in AI Code and Write a Verifier without hints. Afterward, add one automated check to your team's repository that would have caught a bug in AI-written code.

  4. Days 61–75

    Prepare for the market. Read The AI-Assisted Interviews Handbook and run a mock round with a friend where you review a generated solution aloud. Rewrite your résumé using the portfolio handbook, leading with two decisions you can defend.

  5. Days 76–90

    Price it. Read the negotiation handbook and calibrate a range with the AI Salary Explorer. Then revisit your delegation list from day 20, update it, and decide your next quarter's focus.

Questions about this path

Will AI replace software engineers?

Nobody can answer that with certainty, but the pattern so far is that AI makes producing code cheaper while the work around it stays human: deciding what to build, specifying it precisely, reviewing the output, and owning the result in production. Engineers who treat AI as a fast junior colleague, and who can verify its output, are in a stronger position than those who ignore it or paste its output blindly. This path focuses on that second set of skills because they transfer across roles and tools.

What skills should engineers learn in the AI era?

Four stand out in this path. First, directing coding agents with clear specs and well-organized context. Second, reviewing generated code adversarially, since plausible code can still be wrong. Third, building verifiers and evals that tell you automatically whether output is acceptable. Fourth, communicating judgment: in interviews, a portfolio and negotiations. Underneath all four sit the fundamentals, because you cannot review what you do not understand. The steps are ordered so each skill builds on the one before it.

How long does it take to adapt to AI-assisted engineering?

The path is laid out as ninety days alongside a job, with about a sitting per step. Most people feel comfortable directing an agent on small features within two or three weeks, but building reliable habits for review and verification takes longer, because you only learn what goes wrong by shipping real work. Plan roughly ninety days to cover everything including the interview and negotiation material, then keep practicing on actual tasks.

Is vibe coding bad?

No, it is a tool with a limit. Conversational, prompt-and-see coding is excellent for prototypes, throwaway scripts and exploring an idea. It breaks down when others depend on the result, because nothing records what was intended or checks that it works. The handbook in this path treats it as a dial rather than a sin: use spec-driven development when requirements are shared, the code will live a long time, or a bug is expensive.

Every engineering role is being reshaped by AI in the same way: the parts that produce plausible output — code, config, tests, drafts — get cheap, and the judgment to direct, verify, and own that output becomes the moat. This path is the role-agnostic version of that adaptation, built as an ordered, trackable arc rather than a pile of advice.

You start by seeing the trend, then read the role shift in depth (the AI-era handbook for your role), then build the new stack hands-on: agentic coding and spec-driven development for producing work, adversarial review and verifier design for trusting it. You finish on the career side — the 2026 interview, a portfolio of judgment, and negotiating the premium those skills command. Follow it end to end and it doubles as a 90-day plan.

← All learning paths