# AI-Native Software Engineering

> AI-Native Software Engineering by Alfonso Graziano (O'Reilly). Build production software with AI agents, context engineering, and spec-driven development. Written by Alfonso Graziano (AI Lead at Nearform) and published by O'Reilly Media. Out now in Early Release; print edition February 2027.

This site is the companion to the book: what it covers chapter by chapter, a free 7-day learning roadmap, a team workshop canvas, a maturity assessment, and long-form essays on the pillars of the practice.

Every page below is served as HTML and as Markdown. The Markdown URL of any page is the page's URL with `.md` appended — so https://ainativesoftware.engineering/canvas and https://ainativesoftware.engineering/canvas.md are the same page. The links here point at the Markdown.

## The book

- [AI-Native Software Engineering — the O'Reilly Media book](https://ainativesoftware.engineering/book.md): What the book covers, chapter by chapter: who it is for, what you will learn, and where to read it.
- [Table of contents](https://ainativesoftware.engineering/book/toc.md): Every chapter and all 359 sections, read from the manuscript's own contents file.
- [Sources](https://ainativesoftware.engineering/book/sources.md): Every paper, post and tool the book cites — all 181 links, grouped by chapter.
- [Updates and amendments](https://ainativesoftware.engineering/book/updates.md): Corrections and amendments to the book, dated and chapter by chapter.
- [The pillars of AI-native engineering](https://ainativesoftware.engineering/pillars.md): The foundations the practice rests on: context engineering, human-in-the-loop, spec-driven development, and verification.

## Free tools

- [Spec Kit vs OpenSpec vs BMAD vs Kiro vs Agent Skills](https://ainativesoftware.engineering/compare.md): A side-by-side comparison of the spec-driven development frameworks across 25 criteria: workflow shape, review gates, brownfield support, cost and lock-in.
- [The agentic loop, playable](https://ainativesoftware.engineering/agentic-loop.md): An AI coding agent runs a real task across 6 turns — reason, act, observe, adjust — with the context window filling as it works and 3 moves left to the reader.
- [Become an AI-Native Engineer in a week](https://ainativesoftware.engineering/roadmap.md): The free 7-day path from AI user to AI-native engineer, theory and practice for every topic.
- [AI-Native Engineering Canvas](https://ainativesoftware.engineering/canvas.md): A free, printable workshop template for designing how your team adopts AI-native engineering: eight areas from framing and roles to verification and scaling.
- [AI-native engineering maturity assessment](https://ainativesoftware.engineering/assessment.md): 29 questions across 5 areas, a score out of 100, and the list of what nobody on the team knew.
- [AINE Readiness Analyzer](https://ainativesoftware.engineering/readiness.md): A free skill that audits how ready a codebase is for AI coding agents: 46 checks across 5 areas, a score out of 100, and the fixes ranked by what to do first.
- [The AI-Native Baby Steps](https://ainativesoftware.engineering/baby-steps.md): The 7 steps that make a codebase safe for AI coding agents, in the order to do them. A test safety net first, rolling it out to your whole team last.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.
- [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.

## About

- [Newsletter](https://ainativesoftware.engineering/newsletter.md): Chapter drops as they land, the working notes behind the manuscript, and launch day. No spam.

## The pillars of AI-native engineering

- [Context engineering for AI agents](https://ainativesoftware.engineering/pillars/context-engineering.md): The design and runtime management of everything an LLM sees before it answers — system prompts, tools, memory, retrieval — and the discipline of giving an agent just enough of it.
- [Human-in-the-loop collaboration with AI agents](https://ainativesoftware.engineering/pillars/human-in-the-loop.md): The processes and gates where humans review, refine and approve what an agent produces — and the tradeoffs that decide how much review a task actually deserves.
- [Spec-driven development with AI agents](https://ainativesoftware.engineering/pillars/spec-driven-development.md): Treat a human-readable, testable specification as the primary artifact, and split the work into small spec, plan and task cycles that an agent implements against.
- [Verification and quality gates for AI-generated code](https://ainativesoftware.engineering/pillars/verification-and-quality-gates.md): The layered machinery that checks what an agent produced (deterministic gates, LLM review, safe deploys, runtime ops) and the rules that route the few changes still worth your attention.

## Optional

- [The whole site in one file](https://ainativesoftware.engineering/llms-full.txt): every page above, concatenated, for one-request reading.
- [The canvas as a printable PDF](https://ainativesoftware.engineering/aine-canvas.pdf): the 8-area workshop template, ready to print.
- [Read the book on the O'Reilly platform](https://www.oreilly.com/library/view/ai-native-software-engineering/0642572352530/): the Early Release, with the code ANSE2026 for 30 days of free access.
- [The newsletter](https://ainativeengineering.substack.com/): chapter drops and working notes.
- [The author](https://www.alfonsograziano.it): Alfonso Graziano, AI Lead at Nearform, Agropoli, Italy.