Skip to main content
Cover of AI-Native Software Engineering, by Fabio Valencio
The book

AI-Native Software Engineering

An operational guide to building software with agents without outsourcing engineering to them.

When agents begin implementing larger parts of a system, knowing how to generate code is no longer enough.

You need to know how to turn intent into decisions, carry context into execution, coordinate agent work, confirm results with evidence, and learn from what happens after software reaches production.

This book organizes that work into an engineering method.

Available in English and Portuguese.

The code changed. So did the engineering work.

Tools change in months.What you need to know cannot change with them.

  • A new model writes better code.
  • A new agent works for longer.
  • A new IDE automates another part of the process.

None of that answers the questions that remain yours:

  • What exactly needs to be built?
  • Which decisions must survive execution?
  • What context does the agent need to act correctly?
  • How do you know the result is right?
  • What changes when reality contradicts the plan?

AI-Native Software Engineering is about those questions.

Not about learning how to operate this month’s tool.

From vague request to a result you can defend

The book follows the whole job.

  • Turn intent into something executable

    Move from ambiguous goals to requirements, decisions, architecture, criteria, and boundaries that do not depend on someone guessing what you meant.

  • Make context survive the conversation

    Organize knowledge, decisions, and rules so the next agent does not have to reconstruct the project from messages, memory, or assumptions.

  • Coordinate agents without giving away responsibility

    Decompose work, define boundaries, organize execution, and treat agents as participants in an engineering system, not text boxes receiving tasks.

  • Confirm before you trust

    Use criteria, tests, review, and evidence to distinguish “the agent says it is done” from “we have verifiable reasons to accept the result”.

The method

Define. Orchestrate. Confirm. Observe. [re]Define.

The five movements form a cycle because software does not end when code is produced.

  1. 01

    Define

    Decide what must be true before execution begins.

  2. 02

    Orchestrate

    Organize agents, context, tools, and environments to perform the work.

  3. 03

    Confirm

    Confront results with criteria and evidence before accepting them.

  4. 04

    Observe

    See what happens when the system meets users, load, cost, failures, and reality.

  5. 05

    [Re]define

    Carry what was learned back into the decisions and begin the next cycle from a better state.

The book develops this cycle as an engineering method, not as a sequence of commands for a particular tool.

This is not a prompt book

It is a book about what remains the engineer’s responsibility.

  • It does not matter if the model changes tomorrow.
  • It does not matter if your team changes IDEs.
  • It does not matter if an agent begins executing a task that still requires a person today.

Intent, architecture, context, criteria, responsibility, verification, and learning still exist.

That is the layer this book is about.

For engineers on the other side of the shift

If you already know that “using AI to code” is only the beginning, this book is for you.

  • You build software and already use agents

    but execution gains are exposing weaknesses in specification, context, and review.

  • You lead engineers who use agents

    and need a process where speed does not destroy architecture, quality, or accountability.

  • You design systems

    and need decisions and constraints to survive increasingly automated execution.

  • You build AI products

    and want to treat agents, evals, context, and verification as systems engineering, not a collection of prompts.

  • This is not an introduction to programming.
  • It is not a tool catalog.
  • It is not a guide to “prompts that work”.
From the book to a real project

The method does not end on the last page.

DOCOD also has an open-source reference implementation.

The book explains the principles, decisions, and mental model.

The runtime shows one way to make parts of that process executable: connected artifacts, approvals tied to content, work derived from decisions, and verification supported by evidence.

You can use the method without using the runtime.

And you can inspect the runtime to see what these ideas look like when they leave the page.

AI-Native Software Engineering

Read it before you decide.

Get a chapter for free and judge the thesis, technical depth, and method for yourself.

No marketing summary. Read the actual book.

or

by Fabio Valencio

Available in English and Portuguese.