Quick takeaways
- Use AI where code review, tests, and verification stay in the loop.
- Start with small repo tasks before you delegate multi-file changes.
- Pair coding agents with documentation, RAG, and MCP instead of treating them as isolated tools.
Andrej Karpathy on moving from vibe coding to agentic engineering
Sequoia Capital hosts Andrej Karpathy on how developer workflows are shifting toward agentic engineering.
Developer workflow principles
Developers get the most value from AI when the workflow remains inspectable. Ask the tool to explain intent, inspect the repository, make a small change, and show the diff. The point is not speed alone; it is faster iteration with the same or better standards.
The worst pattern is accepting AI output because it looks right. The best pattern is using AI to explore faster, then verifying with tests, review, and your own understanding.
Coding agent stack
Cursor or Windsurf
Use an AI-first editor for repo-aware changes and code navigation.
GitHub Copilot or CodeRabbit
Use PR review support and code generation with human approval.
Qodo or test workflows
Keep test generation and edge-case analysis in the loop.
Claude Code or Codex
Use agentic coding tools for scoped implementation tasks.
Choose your stack
| Your situation | Recommended stack |
|---|---|
| You want an AI-powered editor | Cursor or Windsurf |
| You prefer terminal/agentic workflows | Claude Code or Codex CLI |
| You need inline IDE suggestions | GitHub Copilot |
| You want AI-assisted PR review | CodeRabbit, Qodo, or PR-Agent |
| You need connected tools and APIs | MCP with the right servers |
Testing AI-generated code
AI-generated code should pass the same quality bar as hand-written code. In practice, that means:
- Run the existing test suite before and after the change.
- Ask the agent to identify edge cases and write tests for them.
- Inspect the diff for hidden assumptions, especially around error handling.
- Do not merge code you do not understand. Ask the agent to explain the change until you do.
Where RAG fits
RAG is the right pattern when the assistant needs current documentation, architecture notes, or product truth. Developers can use it for runbooks, API docs, internal knowledge bases, and support context.
When to use MCP
MCP becomes useful when an assistant should inspect files, read structured context, or interact with tools through a governed interface. Use read-only first, then add drafts, then limited writes.
Code review habits
Review AI code with the same skepticism you would apply to a junior contributor's pull request. Look for:
- Missing error handling and logging.
- Over-engineered solutions that ignore existing patterns.
- Tests that look correct but do not actually assert behavior.
- Changes that touch unrelated files.
Weekly developer rhythm
- Use a coding agent for one small repo task.
- Have the assistant summarize what changed and why.
- Check tests and add the missing ones if needed.
- Save the prompt or instruction set if the workflow worked well.
Without AI vs. with AI
| Task | Without AI | With AI |
|---|---|---|
| Code understanding | Developers read files, docs, and history manually to orient themselves. | AI agents map dependencies, summarize behavior, and answer targeted questions about the codebase. |
| Boilerplate | Teams copy-paste snippets from older projects and hope they still fit. | AI drafts context-aware boilerplate from prompts and conventions, then waits for review. |
| Tests | Developers write tests from scratch after the implementation is done. | AI proposes tests from requirements and code paths, which engineers refine before merging. |
| Code review | Reviewers scan large diffs and rely on memory to catch risky changes. | AI flags risks, suggests missing tests, and highlights deviations from team conventions. |
| Documentation | Docs drift behind the code because updating them is tedious. | AI drafts doc updates from code changes for the author to verify and publish. |
FAQ
Should developers trust coding agents on production code?
Only with review, tests, and tight scope. The output should be inspected like any other code change.
What should developers automate first?
Start with repo understanding, tests, docs, and pull request summaries before touching write actions.
Do developers need RAG and MCP?
Not always, but both become useful once a codebase or workflow depends on reliable context and governed tool access.
How do I avoid over-relying on AI?
Require explanations, keep code reviews strict, and make sure you can maintain the code without the agent.
What is the biggest coding risk with AI?
Subtle bugs that look correct at a glance, especially in error paths and concurrency.
Can AI help with legacy code?
Yes. Use it to summarize, annotate, and propose safe refactorings, but verify every proposed change against existing tests.
Can AI replace senior engineers?
No. AI accelerates exploration and drafting; architecture, judgment, security, and accountability still require experienced engineers.
Should we let AI commit code automatically?
Only after review, tests, and a clear approval path. Start with draft-and-recommend, then increase autonomy as reliability improves.
Which developer tasks should AI handle first?
Reading code, writing tests, doc updates, small refactors, and repetitive boilerplate are low-risk places to start.
How do we keep AI-generated code safe?
Require the same reviews, tests, linters, and security checks as human-written code, and reject unrelated refactors.