# The 4 Patterns of AI Native Development

Patrick Debois

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/9u6xvcNJaxc-4-patterns-ai-native-development) · [Video](https://www.youtube.com/watch?v=9u6xvcNJaxc)

## The Four Patterns of AI-Native Development

As agents take on implementation, developers spend more effort reviewing work, specifying intent, discovering useful products, and preserving what the team learns.

Familiarity with code review, version control, and software delivery workflows is helpful; no experience building AI agents is required.

### What changes when development becomes AI native?

[0:01](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=1s)

What changes in software development when AI does more than complete the next line of code? The technology has progressed from language models to retrieval-augmented generation (RAG) and codebase indexing, then to functions exposed through the Model Context Protocol (MCP), agents, and emerging teams of agents. But adding those capabilities does not, by itself, establish a new way of working. Like the earlier shift to cloud-native development, the deeper question is which practices change once the technology becomes part of the workflow.

A developer’s job is a bundle of tasks, including collaboration as well as writing code. New technology can replace some tasks, enhance others, and create work that did not exist before. **AI-native development changes that bundle of responsibilities.** Patrick Debois organizes these changes into four patterns, each moving outward from the developer’s existing role.

![Slide titled “Unbundling tasks” with three rows of colored task blocks showing an original job bundle, technology complements and substitutes, and a post-substitution bundle.](https://ai.engineer/api/talk-essay-media/8eb8a1455a262c6b74ef129eb165324d2cfae0242e3f6f69f8d10af9582740cc)

Unbundling tasks: technology changes the bundle of tasks within a job.

Debois approaches this through his background in DevOps and DevSecOps: automation changes how people coordinate and supervise work, not just how quickly individual actions happen. Introducing himself as an independent industry advisor, he also describes his work curating software-engineering stories for the AI Native Dev community.

### Producer to manager: redesigning review

[2:11](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=131s)

When agents produce the code, the developer becomes responsible for managing that production. The immediate difficulty is review: Debois observes that less time spent coding can mean more time spent reviewing, with greater cognitive load. While writing a change yourself, you develop an understanding of its decisions as you go. With generated code, you have to reconstruct that thinking afterward.

The review interface therefore matters. A red/green diff exposes edits, but can be clunky to interpret; a chat transcript preserves the interaction, but can be verbose. Debois contrasts these with a **What Matters view** that distills the material needed for an acceptance decision. For changes spanning multiple files, a guided sequence can give the reviewer a coherent path through the work. Diagrams offer another representation, making relationships, errors, and the impact of a change easier to inspect.

These examples lead to **moldable development environments**: editors that adapt their presentation to the code, domain, and review task at hand. A structural change may deserve a diagram; another change may need a focused summary or a sequence of smaller reviews. Debois presents this as a possible direction for IDEs, with the aim of reducing the effort required to understand generated work instead of presenting an endless stream of text.

### Controls for longer-running agents

[4:34](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=274s)

Greater autonomy also changes when review happens. [Aider](https://aider.chat/docs/git.html) illustrates the inversion: automatically commit generated changes, then let the developer inspect and reject unwanted work, rather than requiring a manual yes before every commit. Automatic committing does not validate or deploy the code. Debois connects the broader move toward auto-acceptance with judgments about risk and impact: which changes are acceptable without stopping the workflow?

Longer-running agents need recovery points as well as acceptance decisions. **Checkpoints** let a developer return to an intermediate state and regenerate from there. That avoids restarting the entire iteration and reviewing all of it again when only a later portion needs correction.

Delegation also needs explicit boundaries. A file lock expresses that a particular file must not change; agent permissions define which actions are allowed. The displayed editor example puts a `Lock file` action beside a checklist of permissions. These controls turn a manager’s instructions about what may and may not be touched into limits on the agent’s work.

![Slide titled “AI, can’t touch this” showing a yellow arrow pointing to “Lock file” in an editor menu beside a checklist of agent permissions.](https://ai.engineer/api/talk-essay-media/9021ca1917f01c1ebd9a90985f666f797137a241ffc0cecacc3157e1419b07d0)

File locking and agent permissions define what AI can change.

The unit of attention then expands from an individual prompt to the entire task. Debois’s displayed long-running task example costs almost $10. The workload, duration, model, and billing conditions are not specified, so the useful lesson is to track cost per task as agents work for longer stretches. Supervising their output includes supervising the resources they consume.

### Implementation to intent

[6:10](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=370s)

Managing generated code leaves an earlier question unanswered: what should the agents build? The second pattern moves attention from directing the implementation toward specifying the intended result. The developer describes the outcome and gives the agent room to work out how to achieve it.

A simple starting point is a reusable Markdown specification included with the prompt. Functional and technical requirements no longer have to be typed again in every conversation. For example, a small specification for an issue-list feature could make the desired behavior explicit:

```markdown
# Issue list filtering

## Functional requirements
- Let users filter issues by status: open or closed.
- Show all issues when no status is selected.
- Preserve the selected status when the page reloads.

## Technical requirements
- Store the selected status in the URL query string.
- Use the project's existing issue-list component.
```

The file gives subsequent requests a stable statement of what the feature should do, instead of relying on repeated instructions scattered through chat.

Once intent is written down, AI can help turn it into an execution plan. Debois shows GitHub’s task-oriented approach as an example of translating a requested outcome into steps. The resulting workflow is:

1. **Specify** the desired behavior and constraints.
2. **Plan** the tasks needed to satisfy them.
3. **Generate code** from that plan.

This changes the primary interaction from chat and text completion to defining and supervising tasks.

A specification-centric tool can extend that approach across functional, technical, and security requirements. The specification becomes the organizing surface for the workflow, with less attention devoted to the code itself. Taken further, the developer’s role starts to resemble program management: overseeing the process that turns intent into implementation, without necessarily watching every coding step.

### Delivery to discovery

[8:10](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=490s)

A clear specification can still describe the wrong thing. The third pattern moves another step upstream: discovering which intent is worth pursuing. With production pipelines handling delivery, specifications guiding the work, and developers managing agents, more attention can go toward exploring the problem and deciding what to build.

Rapid prototyping is the first expression of this shift. Debois points to [Lovable](https://docs.lovable.dev/introduction/welcome) and [Bolt](https://support.bolt.new/get-started/intro-bolt) as tools for building prototypes through vibe coding. The value is not limited to producing one design more quickly. Generating several versions gives people alternatives to compare and can suggest possibilities they had not considered.

Discovery then becomes a repeated design-to-code loop: create a design, generate the implementation, reconsider the design, and modify the code. Each iteration helps clarify what the product should become.

Debois extends this into a customer-facing possibility. Imagine customers creating the interface they want on top of an existing product. Rather than choosing only among interfaces the product team supplied, they could adapt the experience to their own needs. He compares the idea to intensified A/B testing: customer-created variations could help expose the friction between the product’s default interface and the way people actually want to use it. This is a proposed use of the workflow, not a demonstrated deployment.

### Content to knowledge

[10:15](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=615s)

Discovery produces ideas; specifications record intent; managed agents produce code. All of those activities also produce learning. The fourth pattern is to turn that content into reusable knowledge so the team does not keep solving the same problems.

The inputs extend beyond the codebase:

- **Production issues:** bring what happens in operation back into the code.
- **Incident response:** retain what failed, what should not be repeated, and which guidelines or technologies need to change.
- **Codebase lessons:** explain the existing system to help people onboard and preserve understanding when someone leaves.

The codebase-to-lessons example shows a Shoulder.dev dashboard with cards for learning, codebase exploration, dependencies, and contributing. It makes the knowledge goal concrete: existing software can become material people use to understand and work on the system.

![Slide titled “Turn codebases into lessons” showing a Shoulder.dev dashboard with orange cards for learning, codebase exploration, dependencies, and contributing.](https://ai.engineer/api/talk-essay-media/b123244c974c4a430ec716b36cfc79179ed400ea4b2239015b13429a038e47e7)

Turn codebases into lessons with Shoulder.dev.

### Remembering decisions while the work happens

[11:31](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=691s)

One especially useful form of retained knowledge is **feature memory**. A team tries a feature, dismisses it, and later tries it again because the original decision has disappeared from view. Recording the attempt and its rationale gives the next discussion context. Decisions that would otherwise remain buried in tickets or architecture diagrams become knowledge the team can bring into future work.

Capture can happen inside the development workflow. As a person chats and codes, an agent can identify something potentially worth retaining and propose saving it as knowledge. The proposal is the important intervention: useful context is recognized while it is still available, rather than depending entirely on a separate documentation pass. Debois describes a feedback loop in which both the person and the AI benefit from retaining what they learn.

That retained knowledge has two destinations. It can help answer other people’s questions, and it can inform later coding work. The result of one development cycle becomes context for the next, connecting what the team has already learned with the solutions it generates.

### Development reaches into adjacent roles

[12:38](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=758s)

The four patterns widen the developer’s responsibilities into areas that already exist elsewhere on a software team:

| Pattern | Adjacent responsibility |
| --- | --- |
| Producer → manager | Operations: supervise work and its execution |
| Implementation → intent | QA and architecture: define requirements |
| Delivery → discovery | Product ownership: decide what to build |
| Content → knowledge | Data engineering: turn information into reusable knowledge |

Debois connects this broader scope with what good senior developers already do. **The change reaches beyond faster typing:** it concerns the judgment needed to direct work, choose useful outcomes, and retain understanding across development cycles.

![Diagram placing Development between Product, Operations, QA & Architects, and Data, with transitions from delivery to discovery, producer to manager, implementation to intent, and content to knowledge.](https://ai.engineer/api/talk-essay-media/8c2b72d3ad71f0afe3a2a82de8b8de4eed322f7caef50f3c29c630c63901b72c)

Four AI-native development patterns connect development with adjacent roles.

For further exploration, Debois points to the AI Native Dev landscape and its news coverage at the intersection of software engineering and AI. He estimates that the landscape contained roughly 300 tools at the time of the talk. The original site now leads to the [Tessl community](https://tessl.io/community). The tools provide examples to explore, while the four patterns describe the responsibilities that change as those tools enter everyday development.

## Resources

- [The four AI Native Dev patterns](https://tessl.io/blog/the-4-patterns-of-ai-native-dev-overview) — Patrick Debois introduces the four patterns and connects them to responsibilities across software teams.
- [From Producer to Manager](https://tessl.io/blog/from-producer-to-manager) — Debois explores review interfaces, acceptance fatigue and the responsibilities of supervising generated code.
- [From Implementation to Intent](https://jedi.be/blog/2025/from-implementation-to-intent/) — A companion explanation of reusable prompts, shared specifications and tests that validate intended behavior.
- [Aider Git integration](https://aider.chat/docs/git.html) — Documentation for automatic commits, reviewing changes, undoing edits and configuring Git integration.
- [Lovable documentation](https://docs.lovable.dev/introduction/welcome) — Current guidance for creating and iterating on web applications through natural-language instructions.
- [Introduction to Bolt](https://support.bolt.new/get-started/intro-bolt) — Current guidance for turning prompts into applications and refining them through chat and code editing.
- [Tessl community](https://tessl.io/community) — The current destination of ainativedev.io, with software engineering articles, podcasts and a newsletter.

## Slides

### The 4 patterns of AI Native Development

Four horses emerge from fog as the talk introduces four patterns of AI-native development and their impact on development workflows.

[0:00](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=0s) [Title over four horses emerging from fog.](https://assets.ai.engineer/sites/aiecode2025/sha256/4ea3344b32ec763caaef4a58220e98635d3fb5676c87ebadd6dedfa734466949.webp)

The 4 patterns of
AI Native Development

Interface text:
The 4 patterns of AI Native Development
Pattern 1
From producer to manager
Pattern 2
From implementation
To intent
Pattern 3
From delivery
To discovery
Pattern 4
From Content
To Knowledge
Four AI Native Dev Patterns
[illegible]

### AI Tech evolution

Patrick Debois traces a progression from LLMs through RAG, functions and reasoning to agents with memory, then teams of agents using multiple LLMs and shared knowledge.

[0:11](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=11s) [Diagram traces technology from an LLM through retrieval, functions, reasoning, memory, agents and teams of agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/61adb581902c9025f85a9f135e5096614753e1136508472ef9ee389c853f1672.webp)

AI Tech evolution
Evolution from LLM to Agents - Patrick Debois

Column 1: LLM
Column 2: LLM, RAG
Column 3: LLM, RAG, Functions
Column 4: LLM, RAG, Functions, Reasoning
Column 5: Agent: LLM, RAG, Functions, Reasoning, Memory
Column 6: Agent: LLM, RAG, GraphRAG, Functions, Reasoning, Memory
Column 7: Team of Agents: Agent: LLM, RAG, GraphRAG, Functions, Reasoning, Memory
Column 8: Team of Agents: Agent: MultiLLM, RAG, GraphRAG, Functions, Reasoning, Memory
Column 9: Team of Agents: Agent: MultiLLM, RAG, GraphRAG, Functions, Reasoning, Memory, Shared Knowledge
Column 10: Team of Agents: Agent: MultiLLM, RAG, GraphRAG, Functions, Reasoning, Memory, Shared Knowledge, Tools Former

@patrickdebois
AIE

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Companies adding AI to their products

A sauce-covered meal illustrates the feeling of sprinkling AI onto existing products. Debois asks what new practices would make development AI native.

[0:44](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=44s) [A food photograph accompanies the words Cloud Native, crossed out, and AI Native.](https://assets.ai.engineer/sites/aiecode2025/sha256/23920c6790474360fad4745db981ad9a966f2be5e88272d75cb95ab66b99ce15.webp)

Companies adding AI to their products

Cloud Native [struck through]
AI Native

https://www.linkedin.com/posts/[illegible]_tech-companies-adding-ai-to-everything-ugcPost-7254086590770126848-YTd4

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Unbundling tasks

A job is a bundle of tasks. Technology can complement some tasks and substitute others, reshaping the job bundle; the speaker adds that new tasks can also emerge.

[0:52](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=52s) [Three diagrams show a bundle of job tasks, technology complementing or substituting tasks, and the resulting job bundle.](https://assets.ai.engineer/sites/aiecode2025/sha256/59a359722469aa43bfc2b14e8ee651275c646a42df6a13b4a41fbbb298f6d14d.webp)

Unbundling tasks

PLATFORM REVOLUTION

Every job is a bundle of tasks
Commoditized task
Specialized task
Technology as complement
Technology as substitute

Technology creates complements and substitutes to specific tasks
Commoditized task
Specialized task
Technology as complement
Technology as substitute

The post-substitution job bundle
Commoditized task
Specialized task
Technology as complement
Technology as substitute

SANGEET PAUL CHOUDARY
FEB 25, 2024
https://platforms.substack.com/p/ai-wont-eat-your-job-but-it-will

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Four AI Native Dev Patterns

Debois maps four shifts around development, connecting developers to product, QA and architects, operations, and data: delivery to discovery, implementation to intent, producer to manager, and content to knowledge.

[1:27](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=87s) [Development sits between product, operations, data, and QA and architects, with four labeled shifts connecting them.](https://assets.ai.engineer/sites/aiecode2025/sha256/676191f4d48b66a99175a8dff955d983280491dcc9cd63832fd1474722e227e1.webp)

Four AI Native Dev Patterns

QA & Architects
From implementation to intent

Product
From delivery to discovery
Development
From producer to manager
Operations

From content to knowledge
Data

@patrickdebois

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content To Knowledge
Four AI Native Dev Patterns

### Who am I

Patrick Debois is an independent industry advisor whose DevOps and DevSecOps automation background connects with his interest in engineering with AI. He also curates AI Native Dev community content.

[1:50](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=110s) [Patrick Debois introduces his advisory work, engineering interests and AI Native Dev community role beside his portrait.](https://assets.ai.engineer/sites/aiecode2025/sha256/26ceecf8b5d2993f9643d947fde7a2b6739eb361b52cc5a041e42f5a758ce6b5.webp)

Who am I

• Patrick Debois
• Independent Industry Advisor
• Dev,Sec,Ops | now Engineering with AI
• Inspiring Engineering: Talks , Workshops , fractional CTO
• Curator https://ainativedev.io

https://www.linkedin.com/in/patrickdebois/

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation To intent
Pattern 3: From delivery To discovery
Pattern 4: From Content To Knowledge
Four AI Native Dev Patterns

### Comparing code review views

DeBois contrasts a red/green diff and verbose chat explanation with the What Matters view: a compact review of the correction and new function, designed to make a yes/no decision easier.

[2:55](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=175s) [A chat explanation sits beside a concise code view showing a correction and a circle-area function.](https://assets.ai.engineer/sites/aiecode2025/sha256/6688ac756af61d5d79d5f97fd26e7c4b6442829fb8a167a48e55a66b678f6dd6.webp)

chat view

To fix the linter error and add a function to calculate the area of a circle, I'll make the following changes to the autocursor.py file:

Explanation of the changes:
1. Removed the stray 'I' at the end of the composer() call, which was causing the linter error.
2. Added a new function calculate_circle_area(radius) that calculates and returns the area of a circle given its radius.

This function uses the math.pi constant for accurate calculations. You can call this function by providing the radius of the circle as an argument.

Code diff:
- composer()I
+ composer()
+
+ def calculate_circle_area(radius):
+     import math
+     return math.pi * radius ** 2

Code view:
    activate_composer()
    keys.write("Write a function to calculate the area of a circle")
    keys.hot_key("enter")
    keys.sleep(1)

# Remove the 'I' at the end of the next line
composer()

# Add the new function to calculate the area of a circle
def calculate_circle_area(radius):
    import math
    return math.pi * radius ** 2

@patrickdebois

Interface text:
autocursor.py 1/1
The 4 patterns of AI Native Development
Pattern 1 From producer to manager
Pattern 2 From implementation To intent
Pattern 3 From delivery To discovery
Pattern 4 From Content To Knowledge
Four AI Native Dev Patterns

### Step-by-step review of generated files

The file list organizes generated artifacts for step-by-step review. The open end-to-end test visits localhost and checks that the homepage heading reads “PatAI.”

[3:31](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=211s) [A code editor shows a file-by-file review with an end-to-end test and a list of generated artifacts.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab5f7cbe7911a04d7f094059c4ccdeb005a0e98437073a923bb602fc7eafc72a.webp)

Step by Step breakdown of tasks

import pytest
from playwright.sync_api import sync_playwright

def test_homepage():
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.goto("http://localhost:5000")
        assert page.inner_text("h1") == "PatAI"
        browser.close()

Terraform
main.tf 1/1

README.md
README.md 1/1

OpenAPI Spec
openapi.yaml 1/1

E2E Tests
test_e2e.py 1/1

This should cover the basic implementation of the application as per the provided specifications.

@patrickdebois
AIE
The 4 patterns of AI Native Development

Interface text:
App.svelte
main.py
.env
main.tf
README.md
openapi.yaml
test_e2e.py
Create New
Completed
Reject all
Accept all
Add files
Type your instructions
Accepted v1 of 1
Save
Reapply
OUTLINE
TIMELINE
Dockerfile
main.tf

The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Reviewing infrastructure changes as a diagram

InfraCopilot shows the path from gateway to API, petstore, events, and Lambda. A prompt proposes splitting the event handler by event type; the diagram makes changes and their impact easier to review.

[3:56](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=236s) [An infrastructure diagram connects a gateway, API, database, events, and a Lambda function, with a prompt to split the function by event type.](https://assets.ai.engineer/sites/aiecode2025/sha256/10e4c5355457cd06e3f77c2fe00c8fb18efeef2145191ce473803a32c1d9e192.webp)

InfraCopilot
Diagrams
https://infracopilot.io/

When petstore rows are added or updated, call a new Lambda with the row references

waf
Main Gateway
API
petstore
OnAddOrUpdate
Events

Split OnAddOrUpdate into OnAdd and OnUpdate based on event type

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Aider auto-commit

Aider auto-commits its changes, allowing review afterward. Git options can disable auto-commits or prevent dirty files from being committed before edits.

[4:32](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=272s) [Aider Git integration documentation beside the title Aider Auto-commit.](https://assets.ai.engineer/sites/aiecode2025/sha256/a1f6a5d858bccbe24fa035cfe6dbfef59985a0affa76edf1e1c136c7cc707b54.webp)

Aider Auto-commit
https://aider.chat/

Disabling git integration
While it is not recommended, you can disable aider’s use of git in a few ways:
- --no-auto-commits will stop aider from git committing each of its changes.
- --no-dirty-commits will stop aider from committing dirty files before applying its edits.
- --no-git will completely stop aider from using git on your files. You should ensure you are keeping sensible backups of the files you are working with.

Commit messages
By default, aider creates commit messages which follow Conventional Commits.

You can customize the commit prompt with the --commit-prompt option. You can place that on the command line, or configure it via a config file or environment variables.

Commit attribution
Aider marks commits that it either authored or committed.
- If aider authored the changes in a commit, they will have “(aider)” appended to the git author and git committer name metadata.
- If aider simply committed changes (found in dirty files), the commit will have “(aider)” appended to the git committer name metadata.

You can use --no-attribute-author and --no-attribute-committer to disable modification of the git author and committer name fields.

Additionally, you can use the following options to prefix commit messages:
- --attribute-commit-message-author: Prefix commit messages with ‘aider: ’ if aider authored the changes.
- --attribute-commit-message-committer: Prefix all commit messages with ‘aider: ’, regardless of

Interface text:
aider
Home
Installation
Usage
Connecting to LLMs
Configuration
Troubleshooting
Example chat transcripts
More info
Git integration
Supported languages
Repository map
Scripting aider
Release history
FAQ
Aider LLM Leaderboards
Aider blog
GitHub
Discord
Aider is AI pair programming in your terminal. Aider is on GitHub and Discord.

### Generation checkpoints

A saved checkpoint offers a way to reset files to an earlier point in the conversation. The speaker describes restarting generation there to avoid reviewing the whole iteration again.

[5:00](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=300s) [A saved checkpoint with an option to reset files to that point in a conversation.](https://assets.ai.engineer/sites/aiecode2025/sha256/c3df660d163f4da3c7f42322a0184ca9e466abb6ed53994fb54c3ee9b6b49747.webp)

Generation checkpoints

4. S[illegible]
Reset all files to this point in the conversation
Checkpoint 2 saved. checkout
while scrolling the bookmarks it should be clear where we arew in the timeline

Interface text:
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### AI, can’t touch this

The slide pairs a file-locking menu with Cline’s agent permissions to show how developers can set constraints on what an AI agent can access and do.

[5:24](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=324s) [An editor’s lock-file menu beside agent permissions for reading, editing, commands, browser use, and servers.](https://assets.ai.engineer/sites/aiecode2025/sha256/1fdcb3700430e9bda1a722a4a15b6af68efcff775dd55120aea11c8343c588ba.webp)

AI, can’t touch this

Interface text:
@patrickdebois
AIE
The 4 patterns of AI Native Development

Code  Preview
Files
src > index.css
src
components
AddBookmark...
BookmarkCard...
App.tsx
index.css
main.tsx
types.ts
vite-env.d.ts
.gitignore
eslint.config.js
index.html

@tailwind base;
@tailwind components;
@tailwind utilities;
@layer base {
  body {
    @apply antialiased text-gray-900;
  }
}
[illegible]

New file...
New folder...
Target file
Lock file
Cut
Copy
Copy path
Copy relative path
Rename...
Delete

Read project files
Allows Cline to read files within your workspace.
Read all files
Allows Cline to read any file on your computer.
Edit project files
Allows Cline to modify files within your workspace.
Execute safe commands
Allows Cline to execute of safe terminal commands. If the model determines a command is potentially destructive, it will still require approval.
Use the browser
Allows Cline to launch and interact with any website in a browser.
Use MCP servers
Allows Cline to use configured MCP servers which may modify filesystem or interact with APIs.

Bolt
~/project
npm install
added 275 package[illegible]
65 packages are [illegible]
run `npm fund` [illegible]

The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

### Tasks and costs

Long-running agent tasks need cost monitoring. This Cline task shows an API cost of $9.4564 alongside token, cache and context-window usage.

[5:45](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=345s) [A Cline task panel displays token usage, cache, context window, and API cost.](https://assets.ai.engineer/sites/aiecode2025/sha256/10f981e8ad98d2bca7f9913ecb5d064fb0643853a950e667192c07c6e872f0de.webp)

Tasks & Costs

Task
I want an admin app that manages a list of tools with name, url, and description. The incoming data can come fr[illegible] See more

Tokens: ↑ 564 ↓ 98.4k
Cache: +1.1m → 13.1m
Context Window: 157.5k / 200.0k
API Cost: $9.4564

Now let's update the approve route to use the ToolService with Supabase.

Interface text:
CLINE
3.82 MB
The 4 patterns of AI Native Development
Pattern 1: From producer to manager
Pattern 2: From implementation to intent
Pattern 3: From delivery to discovery
Pattern 4: From Content to Knowledge
Four AI Native Dev Patterns

## Full transcript

[0:01](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=1s) Today, we're gonna talk about the four patterns of AI-native development and how AI has impacted our development workflow.

[0:11](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=11s) Over this period of GenAI craziness, uh, technology has advanced from simple LLM to kind of RAG and indexing our code bases, adding more kind of functions that would be MCP, and all the way up to agents, and we see the first hint of teams of agents kind of emerging.

[0:30](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=30s) And kind of all that technology is really great, uh, as such.

[0:35](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=35s) And we've seen this explosion before, uh, with cloud native, like a new way, new way of working. And right now it still feels maybe a little bit that we're sprinkling AI on top of this.

[0:46](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=46s) And but what, what does it mean to be AI native? What's the new kind of set of practices that we're heading for?

[0:54](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=54s) Now, with any new technology, right, it impacts our tasks. And tasks that we do, um, is different. It's not just about coding and typing. Uh, we, we kind of work together, we collaborate, and we do a, a set of different things.

[1:10](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=70s) And so what happens is that like part of our job or part of the tasks actually either get replaced, enhanced, or there come new tasks, and that's kind of like that AI native thing that we're looking for.

[1:24](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=84s) What is happening to the way we are working right now? I kind of distilled this into four patterns, uh, and we'll talk about each of them, uh, in this talk.

[1:35](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=95s) Um, you know, with the center being we're a developer, but we're moving into different areas. Uh, and that's the pattern shifts that we see.

[1:45](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=105s) Who am I? Um, I'm an independent industry advisor, and I kind of am known for my work around DevOps and DevSecOps, which is a lot of automation, and that fits right in with the integration with GenAI.

[1:58](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=118s) And that's why I love talking about like software engineering with AI. And I also help kind of the AI Native Dev community, uh, to curate content and to get the stories out, much like this event.

[2:11](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=131s) Now, the first pattern is from producer to manager, and it is when we are used to being the producers of the code, and all of a sudden we have agents that are producing the code.

[2:23](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=143s) So we need to manage those agents. And that's the first pattern shift that we see from producer to manager.

[2:31](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=151s) It is already very visible in a way that, like, the AI is generating the code, and while we spend less time in the coding, the reviewing time goes up.

[2:41](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=161s) And we didn't do the kind of thinking work anymore, so now we have to do the thinking work in the review. So our cognitive load is going up. So that is one of the things that is very visible in a lot of places where AI is added to their workflow.

[2:57](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=177s) Now, we try to reduce the cognitive load by coming up with new ways of reviewing, uh, the code that was generated, not just the diff view, red/green. It's a little bit clunky.

[3:09](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=189s) The chat view is very verbose, but on the right side, you see that the review kind of strips whatever we need, um, to review the code, uh, into, uh, almost like a summary.

[3:23](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=203s) And then we kind of say yes/no. So that is the What Matters view, uh, and it's one way of dealing with becoming that manager. At a glance, you can say, "Yes, no, this is good code."

[3:33](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=213s) Now, as we're doing more kind of, uh, multiple files reviewing, we can do this step by step, so breaking down and kind of, uh, making sure there is a flow.

[3:43](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=223s) Uh, how we review is another way of kind of dealing with the managing of the code.

[3:49](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=229s) And why should we restrict ourselves just to be reviewing text? Um, there... This is an example of creating a diagram of what has changed. A lot easier to review, um, and a lot easier to spot kind of, uh, any errors or any impact on that.

[4:06](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=246s) And this brings, uh, me to the f- uh, the concept of a moldable development environment. We expect kind of the editors to adapt themselves to the code, uh, review at hand, to whatever domain, whatever kind of specifics that we need to review.

[4:21](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=261s) So that is maybe a trend that, uh, IDEs will end up with, uh, and not just end us with an endless stream of text, and that help-- also helps reduce the cognitive load.

[4:34](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=274s) Now, why we even bother to reviewing? Um, Aider was one of the first to set, like, let's auto commit, and if you don't like it, you can review, because now we still had the manual, uh, kind of step of saying yes to commit.

[4:48](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=288s) Uh, this flips the chart. Now, it uses some heuristics to say, "I, I kind of accept the risk," or, "The impact is low," but obviously it is an interesting kind of, uh, evolution in auto-accepting those commits.

[5:02](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=302s) Now, auto-accepting, um, also what we saw emerge is the longer running agents. Uh, there's been checkpoints because we don't wanna generate the whole kinda like train of thought, uh, and kind of the generation.

[5:14](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=314s) We can jump in from a certain point, uh, and regenerate from there. So kind of that is also helping us not having to review, uh, the whole kind of, um, iteration over and over again.

[5:26](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=326s) And we do, do wanna set constraints like, "AI, you cannot touch this," much like a manager sets the rules. "You can do this. You cannot do that." Um, we can say, "Lock the file," um, and we can also say what permissions the agents have, so similar to setting, um, kind of good, uh, guardrails for what the AI

[5:45](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=345s) can do. We start worrying a little bit more on the cost as this is longer running. It is not just about that one prompt. Uh, it is about, like, that long-running prompt.

[5:55](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=355s) So how long did it take? Well, in this case, yeah, almost $10. So we wanna keep an eye on the cost of whatever, uh, task is done. Again, this is us managing a team of agents and not just doing the work.

[6:10](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=370s) So this was the first kind of pattern. Uh, we manage whatever code was being r- uh, produced. Now, if we take a step back, we wanna also think about like what do we actually want the agents to build, and this is pattern two.

[6:24](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=384s) We are, uh, increasingly going from caring less about the actual implementation to specifying the intent to the agents. This is what we want, figure it out, like run with it.

[6:37](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=397s) The first one, uh, that I kinda saw it was a simple markdown file as a specification file that you added to the prompt. This was a very simplistic way of kind of adding specifications instead of us having to rewrite over and over again things in the prompt.

[6:53](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=413s) And this really helped to kind of build that shared functionality, whether that is functional or more technical as a specification.

[7:02](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=422s) And, you know, once we have the things that we wanna build, um, AI can help us build a plan. Uh, this was, uh, GitHub kind of adding this task-oriented, uh, and translating whatever we want it to do, uh, step by step.

[7:17](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=437s) Um, and that brought us to all more like intent-based coding. So it's less about the chat and the text completion, but it's more about like we define the tasks.

[7:27](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=447s) It becomes, uh, kind of like the specification. It builds a plan, and then it does the code. Uh, that is definitely, uh, a new kind of, uh, direction, uh, the tools are taking.

[7:38](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=458s) And then the whole tool could be specification-centric. We don't see the code maybe too much anymore. We specify kind of functional requirements, technical requirements, security requirements, and like the whole workflow is around specifications.

[7:54](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=474s) And then if you go a step further, why kind of still see whatever goes on in that like, um, coding, um, process, and you start just having managing the process as a program manager as such.

[8:10](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=490s) So this was kind of like specifying intent, and before we had specifying being a manager, uh, and watching it do and, uh, work out that intent. But this pattern number three is that we...

[8:25](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=505s) How do you find, uh, find what is the right intent that we wanna build? So we wanna discover ideas, we wanna discover, uh, the, and work the problem as such, and that's pattern number three.

[8:37](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=517s) From delivery, so we care less about it going to production because we have pipelines and that goes out. We have the manager, we have the specifications to us discovering what we want to build.

[8:48](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=528s) And yes, okay, this is just, uh, designing and making much faster to design kind of, um, prototypes. That's one way of kind of exploring like, "Oh, it needs to be like this, it needs to be like that."

[9:02](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=542s) Um, we all know kind of like vibe coding, uh, building prototypes is a lot faster right now, so we can kind of do this, um, with a tool like Lovable or Bolt or any of the other tools.

[9:14](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=554s) Um, what that brings is also it can build multiple iterations and multiple versions so we can choose the best one. Um, like, uh, that really helps us to discover what we really want, and it helps us suggest things that maybe we didn't think about, uh, yet.

[9:33](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=573s) And then that kind of whole design to going to code and kind of like doing design again and then modifying the code, uh, that's, that's a whole process of that is being refined to kind of that discovery process and exploration.

[9:46](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=586s) And this is a great example of like we all think about vibe coding, that it needs to be done for prototyping and discovering ideas, but it could also be done by the customer.

[9:57](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=597s) Like imagine they could vibe code the interface that they want on top of your product, um, similar to almost like an A/B testing on steroids. They can adapt what they need and how they need it, and that's usually like one of those friction points, uh, of getting the, the perfect product.

[10:15](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=615s) Now, we explored everything we wanted to build, then we wrote the specification, and then we managed when it was generating the code. Uh, the one step that even goes, uh, uh, kind of, uh, like after that is that whatever we learned in that process, whatever content we produce, we wanna turn into knowledge because that's kind of the

[10:37](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=637s) final play is us capturing all the knowledge, not having to do the same problems over and over again.

[10:44](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=644s) Now, it doesn't only have to be code, uh, what we learn on the process. It could also be production issues, uh, so we learn whatever is going on in production and we bring that to the code.

[10:55](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=655s) That's one way of learning. We can also learn from incident response, like what failed, what we shouldn't do, like new guidelines, new technology that we, we, uh, wanna improve on, um, similar to writing an incident response code and taking that as knowledge.

[11:12](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=672s) We can also turn whatever code we have into lessons, like reducing the onboarding time of a new person, uh, or a person leaving. Uh, all valuable things. There's a lot of knowledge lost usually, so helping, uh, AI helping us there is very useful, um, in that process.

[11:31](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=691s) And then one thing you might have seen, uh, over the years is that like somebody tried a feature, it gets dismissed, it got tried again. So maybe it can keep actually track of whatever feature in almost like a feature memory, and we're not doing this over and over again, and we keep track of whatever decision that was

[11:49](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=709s) made, which is currently a little bit more of a throwaway kind of things that ends up in, uh, in any of the, the tickets or the architecture diagrams. But now, right now, it keeps that as knowledge, um, on board.

[12:02](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=722s) And then when we actually do this more in the flow, we, we chat, we, we code, and all of a sudden the agent says, "I think this is important.

[12:11](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=731s) Let's save this as knowledge." We kind of get a very beneficial loop- either both for actually the, the human and both for the AI to kind of learn at the same time and keeping that, like, knowledge.

[12:25](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=745s) And that knowledge then can then be used to help others with questions, uh, and to also improve actually the coding, uh, of the solution. So this is a nutshell word for AI Native Dev patterns.

[12:38](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=758s) You see the center was the developer. We moved a little bit to the, uh, land of operations, uh, by becoming a, a, a, instead of a producer, a manager.

[12:49](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=769s) We moved, uh, to more of the QA and the architects, uh, by moving towards the intent. We did more discovery like a product owner, and we turned data into knowledge, uh, similar to our data engineers.

[13:04](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=784s) Now, in essence, this is also what good senior developers do. They do more than just the code, and it also shows that AI is beyond kind of just, uh, us helping to do fa- faster typing as such.

[13:19](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=799s) If you wanna learn more about, like, the landscape of all the tools, I also curate the landscape ainativedev.io. We roughly have about three hundred tools now in our landscape, um, for you to explore.

[13:32](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=812s) Uh, obviously, there's a lot of tools. Um, you can also subscribe to the news, AI Native Dev, um, and, um, anything that, like, we really focus on anything that is at the intersection of coding software engineering and AI, which makes us, uh, a little bit unique in that space.

[13:51](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=831s) Thank you very much. If you're enjoying this talk, um, send me a message on LinkedIn. I will also forward you the slides, uh, or you can kind of subscribe to my YouTube channel.

[14:01](https://www.youtube.com/watch?v=9u6xvcNJaxc&t=841s) Have fun, um, exploring all these kind of new ways of working, and I hope to be back for more. Thank you.
