AI for Engineers.
AI writes the boilerplate, looks up the API, and scaffolds the tests — the typing half of the job is getting cheap. What it cannot do is decide what to build, judge which design will hold in production, or catch its own confident bug. This is the engineer’s home on Vibe Engines: the adaptation path, the agentic-coding workflow, and the judgment that turns you from a code-typer into the person who directs AI and owns the outcome.
What AI changes for engineers
Producing code gets cheap; directing and verifying it gets more valuable. Point your time right.
- Writing boilerplate, glue code, and first draftsDeciding what to build and which design will hold
- Looking up syntax, APIs, and Stack Overflow answersReviewing AI output adversarially — catching the confident bug
- Scaffolding tests and translating between languagesSystem design, trade-offs, and owning production behavior
- Producing more code, fasterJudgment, taste, and directing AI as a fast junior
What changes for engineers, in practice
Five habits for directing AI and owning what it produces.
Specify before you generate
Write the behavior, the constraints and the tests that define done, then let the agent implement against them. A precise spec shrinks the review you have to do afterward, and the tests become the contract you verify against.
Review as if you did not write it
AI code tends to be plausible, tidy and wrong on the case that matters, such as dropping a system prompt once a conversation grows. Read it adversarially, run it, and add the test that would have caught the bug before you accept it.
Keep the context clean
Give the agent a short project instruction file, the relevant files and the task, not the whole repository. Long, noisy context degrades output, so compact or restart sessions and write down decisions the next session needs.
Measure LLM features, do not eyeball them
When you ship a feature that calls a model, build a small golden set, a scorer and a CI gate. Track cost and latency per request as well, since an unmeasured prompt change can quietly double the bill.
Bound what the agent can touch
Run agents with the narrowest credentials and sandboxes you can, require approval for irreversible actions, and treat anything an agent reads from the web or a ticket as untrusted input.
What these habits share is a change in where the effort goes. Typing the first draft is cheap, so the scarce work is deciding what to build, stating it precisely and verifying the result. A model that is right most of the time is dangerous precisely because it invites skipped review, and a careless reviewer can leave the final code worse than the model alone would have produced. That is why the habits above center on specs, tests, measurement and limits rather than on clever prompts. They also compound: a clean project instruction file, a small evaluation set and a narrow sandbox make every later task faster and safer. Expect tools to keep changing; these habits transfer between them.
Start here
Adapt first — direct AI, review it hard, and build the new stack.
Adapt to the AI Era
The role-agnostic adaptation arc — direct AI, review it adversarially, build the new stack, and price the judgment that becomes your moat.
Agentic Coding
Work AI-augmented for real — the agentic coding workflow, from spec to verified change.
The AI-Era Backend Engineer
What changes for backend work as AI writes the code — and where your systems judgment becomes the moat.
The AI-Era Frontend Engineer
The frontend role reshaped — from typing components to owning UX judgment and AI-built UI quality.
Grow into it
The roadmaps and senior-scope guides for where engineering careers head next.
AI Engineer
Prompting to retrieval to agents to serving — the full arc of shipping LLM-powered features.
Staff Engineer
The IC leadership track — scope, technical strategy, and influence without authority.
ML Research Engineer
Build and train the models, not just features on top — math, PyTorch, distributed training.
The Senior AI Engineer
Senior-scope AI engineering end to end — the judgment that ties the whole stack together.
A reading order for engineers
Work through these in order; each assumes the one before it.
- Adapt to the AI EraFollow the role-agnostic arc, from seeing the trend to reviewing AI work and pricing your judgment, as a trackable 90-day plan.
- Agentic CodingLearn the agent loop, the project instruction file and the plan-then-verify workflow.
- Vibe Coding vs Spec-Driven DevelopmentDecide when exploratory prompting is fine and when a written spec with tests should drive the work.
- Spot the Bug in AI CodePractice catching a confident, plausible bug that passes the obvious case.
- The Context Engineering HandbookControl what the model sees under a finite attention budget, the core skill of directing it.
- The Agent Evaluations HandbookLearn to measure whether an AI feature or agent is actually good, beyond a handful of demos.
- AI Engineer roadmapGo deeper into building LLM-powered features, from retrieval and agents to serving and observability.
- The Senior AI Engineer Interview HandbookTest your judgment against the architecture, incident and cost questions staff-level interviewers ask.
- Staff Engineer roadmapFollow the individual-contributor leadership track when scope, strategy and influence become the job.
Questions
Will AI replace software engineers?
AI now writes a growing share of routine code, tests and glue, so the typing half of the job is getting cheaper. It does not decide what is worth building, take responsibility for production behavior or reliably notice when its own output is subtly wrong. Engineers who can specify clearly, review adversarially, design systems that hold up and own outcomes are well placed. No one can promise how hiring will change, which is why the useful response is to build those skills now rather than predict the market.
Where should an engineer start with AI tools?
Start with the workflow rather than the product. Pick a real task, write down what done means including a test, let a coding agent attempt it, and then review the result as critically as you would a stranger’s pull request. Repeat until you can predict where it goes wrong. The adaptation path linked above turns this into an ordered sequence, and the agentic coding handbook covers the project instruction file, plan-then-verify loop and security cautions that make it safe.
Is it worth learning to build LLM features, not just use AI tools?
For most engineers it is. Many products now include model-powered features, and the skills are mostly ordinary engineering applied to a probabilistic component: retrieval, tool design, evaluation, cost and latency control, and failure handling. You do not need to train models. The AI Engineer roadmap covers the practical arc, and the evaluation material is a good first investment because it is what separates a demo from something you can safely ship and change.
Not an engineer? The same honest, role-by-role treatment covers PMs, designers, analysts, and more.
Browse every role guide →