# Become an AI-Native Engineer in a week

> The free 7-day path from AI user to AI-native engineer, theory and practice for every topic.

- **Source:** https://ainativesoftware.engineering/roadmap
- **Site:** AI-Native Software Engineering — https://ainativesoftware.engineering/book

In one week you can learn more than many engineers who haven’t upskilled. This path is your starting point. Work through the theory and practice exercises to learn the mindset and apply it from day one.

- **Length:** 7 days, 40 topics
- **Cost:** Free, no email needed
- **Effort:** Two to three hours a day
- **Shape:** Theory first, then a practice exercise you run on your own machine
- **Words:** about 20,000 across theory and practice

Every topic is its own page, linked below, with the full theory, the practice exercise and the curated videos and articles it is built around.

## [Day 1: What is AI-Native Engineering](https://ainativesoftware.engineering/roadmap/day-1.md)

You'll learn what AI-Native Engineering means and why shifting from implementer to orchestrator matters. This foundation sets the mindset for the rest of the week.

- [What Is AI-Native Engineering?](https://ainativesoftware.engineering/roadmap/day-1/what-is-ai-native-engineering.md) — Definition and scope: AI as a first-class capability across the full development lifecycle, not an add-on.
- [From Implementer to Orchestrator](https://ainativesoftware.engineering/roadmap/day-1/from-implementer-to-orchestrator.md) — How the role is evolving from writing every line to directing intent, constraints, and verification.
- [What AI-Native Engineers Actually Do](https://ainativesoftware.engineering/roadmap/day-1/what-ai-native-engineers-actually-do.md) — The new skill stack: spec literacy, context engineering, orchestration, and quality ownership.
- [AI-Native Teams](https://ainativesoftware.engineering/roadmap/day-1/ai-native-teams.md) — How coding agents change the software development lifecycle at the team level: delegate, review, and own.
- [Why This Matters Now: Career and Relevance](https://ainativesoftware.engineering/roadmap/day-1/why-this-matters-now-career-and-relevance.md) — Staying relevant as the role evolves: why AI-Native Engineering becomes a leadership and multiplier role.

## [Day 2: The Basics](https://ainativesoftware.engineering/roadmap/day-2.md)

You'll learn how LLMs, agents, and tools work together: the building blocks of every AI coding assistant. Understanding these basics helps you use and evaluate tools with confidence.

- [How Large Language Models Work](https://ainativesoftware.engineering/roadmap/day-2/how-large-language-models-work.md) — Tokens, context windows, attention mechanisms, and why LLMs are surprisingly good at code, and where they still fail.
- [Prompt Engineering for Engineers](https://ainativesoftware.engineering/roadmap/day-2/prompt-engineering-for-engineers.md) — How to craft prompts that produce consistent, reliable results, and how the same techniques are used offensively to break AI systems.
- [From Autocomplete to Agents](https://ainativesoftware.engineering/roadmap/day-2/from-autocomplete-to-agents.md) — The evolution from single-turn code completion to autonomous multi-step agents: what defines an agent, how the agentic loop works, and when to use agents versus simpler approaches.
- [Building an Agent in 50 Lines of Code](https://ainativesoftware.engineering/roadmap/day-2/building-an-agent-in-50-lines-of-code.md) — A ground-up look at what an agent really is under the hood: an inference client, a set of tools, and a while loop, using Hugging Face's Tiny Agents as a concrete reference.
- [Memory and State in Agent Workflows](https://ainativesoftware.engineering/roadmap/day-2/memory-and-state-in-agent-workflows.md) — How agents retain and retrieve information across steps and sessions: short-term context, long-term memory, and practical strategies to prevent context rot.
- [AI Failure Modes Every Engineer Must Know](https://ainativesoftware.engineering/roadmap/day-2/ai-failure-modes-every-engineer-must-know.md) — Hallucination, confident wrongness, context drift, and the foundational security risks that arise when AI agents can take actions in the world.
- [Human in the Loop](https://ainativesoftware.engineering/roadmap/day-2/human-in-the-loop.md) — Why keeping humans in the decision loop is essential when working with AI agents, and how to design workflows that stay under control.

## [Day 3: The AI Agents Landscape](https://ainativesoftware.engineering/roadmap/day-3.md)

You'll tour the ecosystem of AI coding assistants and agent runners. Knowing the landscape helps you choose tools with criteria, not hype.

- [What AI Coding Agents Are Out There](https://ainativesoftware.engineering/roadmap/day-3/what-ai-coding-agents-are-out-there.md) — A practical map of the AI coding tools available today, from IDE extensions to cloud-based agents, and the criteria that actually matter when choosing one.
- [Getting Started With an AI Coding Assistant](https://ainativesoftware.engineering/roadmap/day-3/getting-started-with-an-ai-coding-assistant.md) — A practical introduction to using an AI coding assistant day to day, using GitHub Copilot in VS Code as the reference example.
- [From Chat to Plans: A First Step Into Spec-Driven Development](https://ainativesoftware.engineering/roadmap/day-3/from-chat-to-plans-a-first-step-into-spec-driven-development.md) — How plan mode works, why it produces better results than jumping straight to code, and how to use it as your first structured step toward Spec-Driven Development.
- [Best Practices for Coding With Agents](https://ainativesoftware.engineering/roadmap/day-3/best-practices-for-coding-with-agents.md) — The patterns that make the difference between a frustrating agent session and one that actually ships something useful.
- [Cloud Agents: Delegating Work in the Background](https://ainativesoftware.engineering/roadmap/day-3/cloud-agents-delegating-work-in-the-background.md) — How cloud-based coding agents work, when they make sense, and how to use them to clear your backlog without losing control of your codebase.
- [Automated Code Review With AI](https://ainativesoftware.engineering/roadmap/day-3/automated-code-review-with-ai.md) — How AI-powered code review tools work, what they catch, and how to integrate them into your PR workflow without replacing human judgment.

## [Day 4: Context Engineering and MCP](https://ainativesoftware.engineering/roadmap/day-4.md)

You'll learn how to give AI the right context at the right time via rules, skills, and MCP. Strong context engineering is what makes AI outputs consistent and production-ready.

- [From Prompt Engineering to Context Engineering](https://ainativesoftware.engineering/roadmap/day-4/from-prompt-engineering-to-context-engineering.md) — Why the craft has shifted from writing clever individual prompts to curating the full state an agent receives: tools, history, files, rules, and constraints. How that shift changes what good engineering looks like.
- [Rules and Instructions: Persistent Context for Your Agent](https://ainativesoftware.engineering/roadmap/day-4/rules-and-instructions-persistent-context-for-your-agent.md) — How to use rules files, repository instructions, and AGENTS.md to give agents consistent, project-level context without repeating yourself in every prompt. The difference between global rules, project rules, and task-specific instructions.
- [Skills and Commands: Reusable Patterns](https://ainativesoftware.engineering/roadmap/day-4/skills-and-commands-reusable-patterns.md) — How to package reusable capabilities as skills and reusable prompt workflows as commands, so agents can load exactly what they need for a task without bloating the default context.
- [Custom Agents and Personas](https://ainativesoftware.engineering/roadmap/day-4/custom-agents-and-personas.md) — When and how to define specialized agents configured for a specific role or task. How persona definitions, scoped instructions, and the AGENTS.md pattern let you build agents that stay focused and don't overstep.
- [Rules, Skills, Commands, and Custom Agents: Knowing What to Use When](https://ainativesoftware.engineering/roadmap/day-4/rules-skills-commands-and-custom-agents-knowing-what-to-use-when.md) — A clear map of the four context management techniques available in modern AI coding tools, what each one is for, who triggers it, and how to combine them without creating a mess.
- [Model Context Protocol (MCP): What It Is and Why It Matters](https://ainativesoftware.engineering/roadmap/day-4/model-context-protocol-mcp-what-it-is-and-why-it-matters.md) — What MCP is, why it emerged as a standard, and how the client-server architecture connects AI assistants to external data sources, tools, and APIs in a consistent and composable way.
- [MCP Security: What Can Go Wrong](https://ainativesoftware.engineering/roadmap/day-4/mcp-security-what-can-go-wrong.md) — The real security risks that come with connecting agents to external systems via MCP: prompt injection through tool outputs, data exfiltration, confused deputy attacks, and the practices that mitigate them.
- [Harness Engineering: Everything Around the Model](https://ainativesoftware.engineering/roadmap/day-4/harness-engineering-everything-around-the-model.md) — Why the systems wrapped around an LLM — the prompts, tools, sensors, and guardrails — matter as much as the model itself, and how to think about them as a discipline rather than a bag of tricks.

## [Day 5: Spec-Driven Development](https://ainativesoftware.engineering/roadmap/day-5.md)

You'll learn why writing specs before code matters and how the Specify → Plan → Execute loop works. SDD is the methodology that ties AI-Native Engineering together and keeps outputs aligned with intent.

- [Why Spec-Driven Development?](https://ainativesoftware.engineering/roadmap/day-5/why-spec-driven-development.md) — The root problem SDD solves: drift, hallucination, and the limits of vibe coding. Why specs are durable artifacts that survive tool changes.
- [SDD as a Pillar of AI-Native Engineering](https://ainativesoftware.engineering/roadmap/day-5/sdd-as-a-pillar-of-ai-native-engineering.md) — How Spec-Driven Development fits into the broader AI-Native Engineering discipline and why it's the methodology that ties everything together.
- [Spec-kit: The Open Toolkit](https://ainativesoftware.engineering/roadmap/day-5/spec-kit-the-open-toolkit.md) — A hands-on look at GitHub's Spec Kit  how it structures the Specify → Plan → Tasks workflow and integrates with PR review gates.
- [Spec-kit Under the Hood](https://ainativesoftware.engineering/roadmap/day-5/spec-kit-under-the-hood.md) — A 20-30 minute deep dive into Spec-kit's source code. Once you know how it works in practice, reading its templates and commands shows you exactly what prompts drive the workflow and gives you a model for building your own.

## [Day 6: Spec-Driven Development](https://ainativesoftware.engineering/roadmap/day-6.md)

You'll compare BMAD and Spec-kit and build a full-stack app with BMAD. Hands-on practice with SDD frameworks helps you choose the right one for your team and project.

- [BMAD: The AI-Driven Delivery Framework](https://ainativesoftware.engineering/roadmap/day-6/bmad-the-ai-driven-delivery-framework.md) — What BMAD is, how its persona-based workflow guides you from ideation to agentic implementation, and where it fits in the SDLC.
- [The BMAD Workflow Map](https://ainativesoftware.engineering/roadmap/day-6/the-bmad-workflow-map.md) — How BMAD structures the full delivery lifecycle across four phases, and how the Quick Flow track lets you skip phases for smaller, well-understood work.
- [BMAD vs Spec-kit: Choosing the Right Framework](https://ainativesoftware.engineering/roadmap/day-6/bmad-vs-spec-kit-choosing-the-right-framework.md) — A direct comparison of the two main SDD frameworks  when to use each, their trade-offs, and how to decide what fits your team and project.

## [Day 7: AI in the SDLC](https://ainativesoftware.engineering/roadmap/day-7.md)

You'll see how AI-Native practices apply across the full lifecycle: from requirements and architecture through implementation, testing, review, and maintenance. This ties the week together and shows where to apply what you've learned.

- [AI in Requirements and Product Collaboration](https://ainativesoftware.engineering/roadmap/day-7/ai-in-requirements-and-product-collaboration.md) — How engineers can use AI to help gather requirements, turn them into structured user stories, and validate acceptance criteria before a single line of code is written. The SDLC starts before implementation, and AI can make the engineering-to-product handoff much more structured and less lossy.
- [AI as the Bridge Between Design and Development](https://ainativesoftware.engineering/roadmap/day-7/ai-as-the-bridge-between-design-and-development.md) — How AI is closing the gap between what designers create and what engineers implement. Tools like Figma MCP, v0, and Builder.io Visual Copilot let engineers turn design files, screenshots, or prompts into production-ready component code, reducing the manual translation work that traditionally consumed hours every week.
- [Testing with AI](https://ainativesoftware.engineering/roadmap/day-7/testing-with-ai.md) — How to use AI agents to write, run, and maintain tests, from unit tests to end-to-end browser flows. Covers AI-generated test cases, Playwright MCP for browser automation, and the BMAD TEA module for risk-based test strategy and release gates.
- [AI for Documentation](https://ainativesoftware.engineering/roadmap/day-7/ai-for-documentation.md) — Using AI to generate and maintain documentation: code comments, API references, architecture docs, and user-facing guides. Documentation rot is one of the most persistent problems in software teams; AI tools are starting to solve it by coupling docs directly to code and updating them automatically.
- [Continuous AI: AI in Your CI/CD Pipeline](https://ainativesoftware.engineering/roadmap/day-7/continuous-ai-ai-in-your-cicd-pipeline.md) — How AI fits into CI/CD pipelines beyond running tests. GitHub Agentic Workflows, using AI models inside GitHub Actions to auto-triage build failures, fix broken tests, synchronize docs with code changes, and handle repetitive repo tasks that previously required manual effort.
- [AI for Debugging and Incident Response](https://ainativesoftware.engineering/roadmap/day-7/ai-for-debugging-and-incident-response.md) — Using AI to speed up root cause analysis, correlate logs with code changes, and investigate production incidents. Engineers spend a significant chunk of their time debugging; AI tools are already cutting that time by a meaningful amount in real production systems.
- [AI for Your Custom Workflows in the SDLC](https://ainativesoftware.engineering/roadmap/day-7/ai-for-your-custom-workflows-in-the-sdlc.md) — From automating performance audits on a frontend codebase to generating security reports, triaging support tickets or keeping runbooks up to date, almost every task you do in the SDLC can benefit from AI in some way. The key is knowing how to identify those opportunities and structure your workflow to take advantage of them.

## After the week

- The book goes deeper on every one of these: [what it covers](https://ainativesoftware.engineering/book.md).
- Run [the canvas](https://ainativesoftware.engineering/canvas.md) with your team to turn the practices into your own operating model.
- Take [the maturity assessment](https://ainativesoftware.engineering/assessment.md) to see where your team actually stands.
- The roadmap is also a repository: [contribute or open an issue](https://github.com/alfonsograziano/ai-native-engineering).

---

_AI-Native Software Engineering by Alfonso Graziano (O'Reilly Media, Early Release; print edition February 2027). Every page of ainativesoftware.engineering is also served as Markdown: append `.md` to any URL. Index: https://ainativesoftware.engineering/llms.txt — whole site in one file: https://ainativesoftware.engineering/llms-full.txt._