JEDI — Just Enough Developed Intelligence

Two Weeks After "Context Is the New Code" at AIE London: I Did Not See This Coming

Wed, 13 May 2026 00:00:00 +0000

It’s about two weeks after the Context Is the New Code presentation at AIE London. I called it “an unpolished thought” on stage, because that’s what it was. I’d drawn an infinity loop on a slide, and apparently numbered the steps 1-4-3-2 instead of 1-2-3-4, which the internet has been kind enough to point out roughly 200 times. Fair. The diagram was, in fact, vibe-coded.

Sonar Summit 2026 | The Context Flywheel: How the Best AI Coding Teams Pull Ahead

Fri, 13 Mar 2026 00:00:00 +0000

The competitive edge in AI-native development isn’t the model or the coding agent — it’s the organizational context you feed it. In this conversation with Edgar at the Sonar Summit, I walk through why context is the fuel that makes agents perform, and why the teams that invest in building it systematically are pulling ahead.

CI/CD for Context: Same Pipeline, Different Rules

Thu, 05 Mar 2026 00:00:00 +0000

If context is code, can we test it in a CI pipeline? The CDLC says generate, evaluate, distribute, observe. The evaluate step is where it gets real.

I wrote about this on tessl.io: evals are the equivalent of tests for context. But they follow different rules. Seven problems came up, split between how you run evals and what you’re actually measuring.

Part 1: Running evals

Non-determinism. LLMs produce variable outputs even at temperature zero. You can’t treat evals as pass/fail gates. Instead: error budgets. Define an acceptable failure rate in advance. Run a minimum of five trials per scenario (what we do in SkillsBench). Use binary evals over granular scoring.

The Context Flywheel: Winning on Context, Not Models

Thu, 26 Feb 2026 00:00:00 +0000

The Context Development Lifecycle described four stages: generate, evaluate, distribute, observe. That was the what. The flywheel is the why.

Better context produces better agent output. Better agent output generates better signals. Better signals produce better context. Each cycle compounds. By the tenth iteration, the team that invested in context is operating at a fundamentally different level than the team that kept tweaking prompts.

I wrote about this more fully on tessl.io. Here’s what I think matters most.

AI Manager Styles: From Full Visibility to Pure Outcomes

Sun, 22 Feb 2026 00:00:00 +0000

You’re managing the thing that writes code. So what’s your management style?

Most people start the same way: watching every action, approving every tool call. Then they trust more, review less, scale up. It’s an evolution. The management style that works on day one isn’t the one that works on day ninety.

Vincent van den Tol wants to keep track of how his application is built. Not because he doubts Claude Code. Because on larger tasks, you need to see where the agent is headed so you can correct course before it’s gone too far. He’s reaching for tools like fp, Backlog.md, and Vibe Kanban. The tools people are building look remarkably like the tools we already know: kanban boards, task breakdowns, story maps, sprint planning. The same management practices that worked for human teams are being adapted for agent teams.

Intentional Overuse Is an AI Coding Learning Strategy

Sun, 22 Feb 2026 00:00:00 +0000

Every time AI removes one bottleneck, the system reveals the next one. The useful question isn’t “how much faster” but “what breaks next.” That question has been my compass. Intentional overuse has proven a good learning strategy for me.

Yes, if all you have is a hammer, everything looks like a nail. That’s the criticism, and it’s fair as a permanent way of working. But as a learning strategy, you want to use the hammer on everything. That’s how you find out what’s a nail and what isn’t.

Self-Tuning Context: When Agents Rewrite Their Own Instructions

Sun, 22 Feb 2026 00:00:00 +0000

What if the agent could optimize its own instructions? Every time an agent messes up, you open the CLAUDE.md, add a rule, and hope it sticks. You’re the feedback loop: watching output, diagnosing failures, rewriting instructions by hand.

Mitko Vasilev, a CTO focused on enterprise R&D and a vocal advocate for owning your own AI stack, is doing exactly that. He’s running a feedback loop that takes the agent’s skill file, tests it against real tasks on a 20-year-old codebase, and lets the system evolve a sharper version. Locally, offline. The setup:

Think Tax: The Real Cost of AI-Generated Code

Fri, 20 Feb 2026 00:00:00 +0000

Cole Medin’s post on comprehension debt got me thinking. The term is making the rounds — it’s the gap between the code your team has shipped and the code your team actually understands. Unlike technical debt — which you can see and plan around — comprehension debt is invisible until something breaks and nobody knows why.

I’ve been calling it the think tax. Every time you accept AI-generated code without building a mental model of what it does, you’re deferring a payment. And unlike technical debt, which compounds linearly, the think tax compounds exponentially. Once you lose mastery of the system’s logic, every subsequent change carries catastrophic risk.

DevOps Modernization: AI Agents, Intelligent Observability and Automation

Thu, 19 Feb 2026 00:00:00 +0000

I joined Olalekan Elesin (HRS Group), Mallika Rao (Netflix), and Martin Reynolds (Harness) for an InfoQ Live panel moderated by Renato Losio. The conversation centered on how AI is changing DevOps and SRE practices — moving beyond reactive monitoring toward predictive, automated delivery and operations.

The real problem: human attention waste

The panel quickly aligned on what AI should actually solve in operations: reducing the cognitive load of triaging without context, filtering signal from noise, and cutting through alert fatigue. Before you automate remediation, the bigger win is helping humans make faster decisions. AI that summarizes, correlates, and explains is already transforming on-call workflows — and it does not require full autonomy to deliver value.

The Context Development Lifecycle: Optimizing Context for AI Coding Agents

Thu, 19 Feb 2026 00:00:00 +0000

Coding agents can write features and fix bugs. The bottleneck has shifted — from how fast we can write code to how effectively we communicate what we actually want. Context is the new constraint.

Most teams store context informally: .cursorrules files, scattered .md documents, Slack threads, tribal knowledge that lives in people’s heads. None of it is versioned. None of it is tested. None of it has conflict detection. Context rots and conflicts — outdated guidance actively misleads agents without anyone noticing.

Intercepting Prompt Injection at the Syscall Level: A macOS Proof of Concept

Tue, 17 Feb 2026 00:00:00 +0000

When you git clone a repository and open it with Claude Code, the first thing it does is read CLAUDE.md — a project instruction file that shapes how the AI behaves. This happens automatically, before any hooks fire, before you type a single prompt. If that file contains prompt injection, you’ve already lost.

This post describes context-filter, a proof of concept that intercepts file reads at the operating system level to detect and flag prompt injection before it reaches the AI. Along the way, we discovered that Claude Code quietly switched from Node.js to a native Bun binary — which broke everything and taught us a lot about macOS internals.

Unlearning, Experimentation and Engineering Rigor in an Agentic World

Wed, 11 Feb 2026 00:00:00 +0000

In this ThoughtWorks Technology podcast episode, Patrick Debois joins Nathan Harvey (DORA, Google Cloud) and host Ken Mugrage for an in-person conversation about what changes when AI agents enter the software development lifecycle. The discussion centers on a core tension: how do experienced engineers unlearn established habits while maintaining the engineering rigor that keeps systems reliable?

Sandboxing AI Agents: From dclaude to ADDT

Mon, 02 Feb 2026 00:00:00 +0000

When AI coding agents can navigate your filesystem, one wrong move and they’re “helpfully” editing files in your production branch while you’re working on a feature. I built two tools to solve this — starting with a focused wrapper, then generalizing it into something any agent can use.

dclaude: Containing Claude Code

The first iteration was dclaude — a containerized wrapper for Claude Code that isolates filesystem access using Docker. It’s a drop-in replacement with identical CLI syntax: instead of claude "refactor this", you run dclaude "refactor this" while the AI only sees mounted directories.

Automating Claude Desktop via Chrome DevTools Protocol

Wed, 28 Jan 2026 00:00:00 +0000

Electron apps support the Chrome DevTools Protocol. That means Claude Desktop can be launched with a debug flag and controlled programmatically:

/Applications/Claude.app/Contents/MacOS/Claude --remote-debugging-port=9222

Hit localhost:9222 and you can inject JavaScript directly into the UI. From there, things get interesting fast.

What you can do

Extract responses — Use a MutationObserver to capture Claude’s outputs as JSON
Auto-approve MCP dialogs — Automatically click through permission prompts
Voice integration — Pipe Whisper transcription into the prompt field, add text-to-speech on the output
Custom shortcuts — Add keyboard listeners for things like Ctrl+Shift+E to export conversations
Multi-instance orchestration — Run multiple Claude windows on different debug ports, each specialized for a different task

The recursive bit

Claude Desktop runs MCP servers. MCP servers can invoke the DevTools Protocol. Which means Claude Desktop can drive another Claude Desktop instance. The control layer becomes another thing the AI can operate.

AI-Native Everything: Connecting Claude Desktop to My Whole Workflow

Tue, 27 Jan 2026 00:00:00 +0000

It was right under my nose. I’d been optimizing my coding work with AI but completely neglecting everything else — emails, meetings, task management, research. The fix: connect Claude Desktop to all of it via MCP servers.

Standard connectors

The easy wins: Linear, Notion, Google Drive, Slack, Google Calendar, Google Tasks. Plug them in, Claude can read across all of them.

Custom MCP servers I built

The interesting part was building what didn’t exist yet:

Building My Own Tools Instead of Reusing

Mon, 26 Jan 2026 00:00:00 +0000

I’m increasingly writing my own tools with AI rather than reaching for existing open-source libraries. For smaller applications — glue apps, the $5 appstore kind, MCP servers — I can iterate to exactly what I need faster than reading through someone else’s codebase and adapting to their decisions.

I know pretty well what I want, or can iterate fast to get there, versus being dependent on other people’s tools and their priorities.

Trust, Accountability and AI Coding Swarms

Sat, 24 Jan 2026 00:00:00 +0000

A late night conversation with Claude that started with Steve Yegge’s Beads architecture and ended somewhere unexpected. Full conversation (PDF).

The question

Who’s accountable when AI agents write 44,000 lines of code that no human has looked at?

Architecture convergence

Across Beads, Gas Town, Claude Flow, and Cursor’s swarm experiments, the same patterns keep emerging:

Flat peer-to-peer coordination fails — you need hierarchy and roles
State must be external — not in context windows
Small tasks, many workers — not long sessions
Different models for different roles — specialists beat generalists
Humans become orchestrators — not reviewers of every line

“Nobody reviews the code, you review the outcome.”

2025: Make Coding Agents Work. 2026: Make Them Work Better.

Fri, 05 Dec 2025 00:00:00 +0000

2025 was the year of making coding agents work — figuring out what they’re good at, wiring them into IDEs, running them async, mostly in solo dev environments. Exploration phase.

2026 is about making them work better. The shift from “can I use this?” to “how do I scale this across a team?” That means:

Spec-driven development becoming a standard practice, not a nice-to-have
Agent-enablement platforms emerging with analytics and workflow optimization
Deeper insight into coding workflows — understanding where agents help and where they create new bottlenecks
Moving from individual experimentation to enterprise-scale deployment

The new bottlenecks

The interesting pattern: coding itself stops being the bottleneck. What replaces it:

Coding with AI — CTO Club Belgium

Wed, 26 Nov 2025 00:00:00 +0000

Gave a talk at CTO Club Belgium on coding with AI. The session was deliberately interactive — less presentation, more shared experiences. Most CTOs in the room had teams experimenting with AI coding tools, and the conversation quickly moved past the hype into what actually works at scale.

The gap between vibe coding and reality

Everyone wants to vibe code. Most early adopters hit a wall. The tools are impressive in demos but frustrating in real codebases with legacy code, custom conventions, and team dynamics. The gains are real — but only if you use AI the right way.

Code Speed Reading

Fri, 21 Nov 2025 00:00:00 +0000

I wonder if there are code speed reading courses — the way there are speed reading courses for text. As AI generates more code faster than we can review it, the ability to quickly comprehend unfamiliar code becomes a critical skill.

Some interesting perspectives from the conversation that followed:

Build tools to read for you — Tudor Girba’s take: the answer isn’t faster reading, it’s building contextual tools that read through code for you. Same way we scaled functionality checks through automated testing, we need to scale comprehension.
Abstraction as speed reading — Dipan Mehta’s point: when higher-level functions and APIs work as expected, you can skip reading the lines underneath. Good abstraction is speed reading.
Slower might be better — Willem van den Ende’s counter: deliberate, careful comprehension beats skimming. Emily Bache’s Sparrow Deck videos on reading long methods are worth watching.

The underlying question: in a world where AI writes most of the code, does “reading code” remain a human skill or does it become something we delegate to tools? And if we delegate it, what does that mean for accountability?

Spec-Driven Development: 10 Things You Need to Know About Specs

Fri, 07 Nov 2025 00:00:00 +0000

Spec-driven development is no magic bullet, but it’s useful nonetheless. The trap is expecting any technology to solve all problems — or dismissing it when it doesn’t. Treat every new tool as part of your toolkit and understand its strengths and limitations.

Here are 10 things I’ve learned about working with specs for AI-assisted development.

1. What’s a spec, really?

A spec is different from a prompt or interactive coding session. It’s a structured document that captures what you want the system to do — like providing a recipe rather than asking someone to “cook dinner.” The shift is from micromanagement to delegation.

Learning Rate Beats Years of Experience

Thu, 06 Nov 2025 00:00:00 +0000

Senior devs often tell me they’re worried juniors won’t learn what good looks like. Juniors tell me they’re learning much faster with AI helping them stumble along the way.

Both are right. The question is which effect dominates.

Learning rate as competitive advantage

Greg Ceccarelli nailed it: the most dangerous person in any room isn’t the expert with twenty years of experience — it’s the person with solid experience and the ability to master new domains at an accelerated rate. He calls it “intellectual metabolism” — the speed at which you absorb new patterns and abandon outdated assumptions.

Reflecting on The DevOps Handbook

Thu, 30 Oct 2025 00:00:00 +0000

In this episode of the Book Overflows podcast, Patrick joins hosts Carter Morgan and Nathan Tops to reflect on The DevOps Handbook, originally published in 2016. Patrick clarifies his role as a chief consultant and thought partner to Gene Kim rather than a primary author, and shares the origin story of the term “DevOps” itself, which emerged almost accidentally from the need for a shorter name than “Agile System Administration Days” when organizing the first DevOps Days conference in 2009 with just 65 attendees.

Radical Ideas for Code Review Volume

Tue, 28 Oct 2025 00:00:00 +0000

Asked ChatGPT for more radical ideas to deal with code review volume. Suggestion 9 was: just regenerate the code instead of reviewing it. It’s not wrong — but no such product might survive long enough to have users.

The reactions were interesting:

As complexity increases, regenerating could require “a trillion tokens and multiple days” — it doesn’t scale linearly
It might work for “large enough values of N and maybe not the whole codebase at once” — partial regeneration as a review strategy
Someone would fund it anyway

The underlying tension: AI agents generate code faster than humans can review it. The traditional answer is “review better.” The radical answer is “don’t review — regenerate and test.” Neither is fully satisfying yet.

The AI Coding Fabric

Tue, 28 Oct 2025 00:00:00 +0000

Been pondering on what I call the “AI Coding Fabric” — a new infrastructure challenge emerging as AI agents move beyond traditional IDEs into sandbox environments. Platform engineers need to think about:

Agent access rules — who can do what, where
Spec registries — shared, versioned specifications
Code-specific guardrail rules — beyond generic safety, actual coding constraints
Agent/MCP discovery portals — how agents find and use available tools
Code/Agent firewalling — network and filesystem isolation
Code agent observability — what are agents actually doing?
Code knowledge & data sources bill of material — tracking what feeds into generated code

The fragmentation problem

Right now developers choose between: LLM selection, agent framework (Claude Code, Codex), interface, add-ons (MCP), planning framework. These are all separate decisions. Eventually these consolidate into platforms, but we’re not there yet.

Devoxx 2025: 8 Talks on Spec-Driven Development

Tue, 21 Oct 2025 00:00:00 +0000

Curated 8 talks from Devoxx 2025 related to spec-driven development for writing better code with AI. Kudos to Stephan Janssen for another great edition.

Spec Driven Development: Why Your Prompt Chaos Won’t Scale — Simon Maple
Generative AI: Tech du Jour or the Next Big Thing? — Massimo Re Ferrè
Backlog.md: Reaching 95% Task Success Rate with AI Agents — Alexandru Gavrilescu
The New AI Native Dev Coding Workflow — Patrick Debois
Spec Driven Development with Kiro: Vibe Coding with Guardrails — Kevin A. & Adriaan de Jonge
RoboCoders: Judgment Day – AI IDEs Face Off — Baruch Sadogursky & Viktor Gamov
Vibe Coding Your Way into a Security Nightmare — Arjen Wiersma
Understanding Prompt Injection Techniques, Challenges, and Advanced Escalation — Brian Vermeer

The talks tackle spec-driven development from different layers of the stack — from specs and versioned guardrails to AI-assisted IDEs and security concerns. The open question: when do runtime validation and observability become part of this picture?

From DevOps to AI-Native: The Next Great Shift in Software

Wed, 15 Oct 2025 00:00:00 +0000

A conversation with The Secure Disclosure covering the full arc from DevOps to AI-native development — and why the engineering discipline hasn’t changed, even as everything around it has.

The developer as ops person

The central irony: developers using AI coding assistants have effectively become operations people. They receive code they didn’t write and must review, understand, and take accountability for it. This mirrors the historical DevOps challenge — ops teams receiving applications they didn’t build but had to run. All dev people have now become an ops person.

The New AI Native Dev Coding Workflow

Fri, 10 Oct 2025 00:00:00 +0000

Patrick presents a comprehensive framework for understanding how AI is transforming the developer workflow, drawing on his experience curating nearly 500 AI coding tools over the course of a year. Rather than focusing solely on code generation, the talk identifies four key patterns that define the emerging AI-native developer experience: managing agents as a reviewer, expressing intent through specifications, discovering ideas through exploratory coding, and capturing knowledge for continuous learning.

From DevOps to AI-Native: Rethinking Software Delivery

Tue, 30 Sep 2025 00:00:00 +0000

In this TechRox podcast episode recorded ahead of the TechRox Summit, Patrick Debois sits down with host Dimitri Bi to discuss the journey from DevOps to AI-native development. Patrick recounts how boredom with the plateauing DevOps conversation, combined with explorations in the metaverse, digital twins, and gaming automation, naturally led him into the generative AI space. He describes AI as fundamentally an “integration game” — unlike traditional machine learning, it does not require deep mathematical expertise, making it accessible to anyone comfortable calling APIs and writing prompts.

DevOps, AI, and the Future of Engineering

Fri, 19 Sep 2025 00:00:00 +0000

In this episode of the Hangar DX podcast, Patrick joins host Anka Jan to discuss the parallels between the DevOps movement and the current AI transformation in software engineering. Drawing on his history as the person who coined the term DevOps and organized the first DevOps Days, Patrick identifies recurring patterns: the same spectrum of believers and skeptics, the rush of competing tools, and the gradual maturation from initial chaos to established practices. A key difference, he notes, is the unprecedented speed of AI adoption, which leaves less time for ideas to stabilize before the next paradigm shift arrives.

The New Engineering Paradigm: Day 1 Vibe Code, Year 1 Rewrite in Rust

Wed, 03 Sep 2025 00:00:00 +0000

Stan Girard’s lifecycle of modern software — there’s some truth to it:

Day 1: Vibe code with Claude
Week 1: Fix bugs for production
Month 1: Senior engineer optimizes for scale
Year 1: Rewrite in Rust

The punchline: despite using AI extensively, most of the code that goes to production is still human-written. Domain expertise matters. Doing one thing well requires understanding that thing deeply — and that’s not something you can vibe-code your way through.

What AI Thought About My Resume

Tue, 22 Jul 2025 00:00:00 +0000

Fed my resume to AI and let it analyze me. It’s not wrong.

The interesting observation from the conversation that followed: people who enjoy collaborating with AI for coding might share specific personality traits — particularly introverted intuitive types. Whether that’s MBTI pattern-matching or genuine signal is an open question.

The AI assessment didn’t research “deep enough” according to one commenter — it missed the broader impact of inspiring others. Fair point. AI is good at summarizing what’s on paper. The stuff that doesn’t fit on a resume is harder to capture.

4 AI Native Dev Patterns — ServerlessConf Edition

Sun, 20 Jul 2025 00:00:00 +0000

Patrick presents the four patterns of AI-native development at ServerlessConf, framing the rapid evolution of coding tools – from simple tab completions to multi-agent systems that autonomously work across entire codebases. He traces the progression from single-line copilot suggestions through chat-based generation, multi-file edits, terminal and browser awareness, and eventually to tools like Devin that run continuous feedback loops. With over 300 tools now tracked on the AI Native Dev landscape, the space is evolving far beyond what most developers realize.

4 AI Native Development Patterns — Future of Software

Sun, 20 Jul 2025 00:00:00 +0000

Patrick presents the four patterns of AI-native development at the Future of Software event hosted by Eficode. He opens by tracing the rapid evolution of coding tools – from basic tab completions and chat-based copy-paste workflows to multi-file predictions, terminal and browser integration, reasoning models, and continuous autonomous loops like Devin. The key insight is that the technology stack around LLMs has expanded dramatically, and the gap between what most developers experience (copilot-level assistance) and what is possible today (teams of agents working across codebases) is significant.

The 4 Patterns of AI Native Development — AI Engineer Summit Edition

Sun, 20 Jul 2025 00:00:00 +0000

A framework of four patterns that describe how AI is fundamentally transforming the developer role beyond simple code completion. As AI technology has progressed from basic LLM prompts through RAG, function calling (MCP), and into agentic workflows, we are moving from “sprinkling AI on top” toward a genuinely AI-native way of working — one that reshapes the tasks developers perform day to day.

Prove It's Working: AI Swarms That Build Their Own Proof

Fri, 11 Jul 2025 00:00:00 +0000

Igor Moochnick tested an autonomous distributed system built by an AI swarm. When he challenged it to prove it was actually working, instead of empty assurances, the swarm responded: “I’ll implement you a dashboard where you can monitor my progress and status.”

Within 15 minutes, a fully operational monitoring dashboard appeared in the terminal. The swarm had planned the dashboard architecture, split implementation across machines, and coordinated parallel execution — all autonomously.

Automating Claude Code Configuration

Fri, 27 Jun 2025 00:00:00 +0000

Setting up Claude Code feels a bit like being the first DevOps on Mars. Here’s what I learned automating the configuration for CI/CD pipelines and scripted deployments.

API key without OAuth

Skip the OAuth flow — use an API key helper script:

echo 'echo ${ANTHROPIC_API_KEY}' > ~/.claude/anthropic_key_helper.sh
chmod +x ~/.claude/anthropic_key_helper.sh
claude config set --global apiKeyHelper ~/.claude/anthropic_key_helper.sh

Skip onboarding and trust dialogs

claude config set hasTrustDialogAccepted true
claude config set hasCompletedProjectOnboarding true

The ~/.claude.json skeleton needs hasCompletedOnboarding: true and API key trust uses the last 20 characters of your key.

Parallel Coding Agents Are Changing the Developer Workflow

Wed, 25 Jun 2025 00:00:00 +0000

The workflow is shifting: teams parallelize for speed and exploration. Agents decompose specs into subtasks, subagents execute in parallel with coordination, developers provide isolated environments, humans review and merge preferred options, and knowledge gets reused throughout.

The analogy to DevOps is striking. Automation existed before cloud — but cloud infrastructure enabled true parallelism that unlocked transformative power. Similarly, parallel agents are changing the development process itself, not just speeding up individual tasks.

Why AI Needs a Platform Team

Mon, 23 Jun 2025 00:00:00 +0000

Presented at PlatformCon 2025, this talk makes the case that any serious generative AI initiative within an organization deserves a dedicated platform team. Patrick draws on the recurring pattern seen with cloud, mobile, and DevOps adoption: a single team incubates the new technology, a few teams learn to reproduce it, and eventually it must scale across the organization. With AI, the friction point lies between data science teams who have historically owned AI models and engineering teams responsible for production software, with the emerging “AI engineer” role serving as the change agent bridging both worlds.

The 4 Patterns of AI Native Development — TechRocks Edition

Thu, 19 Jun 2025 00:00:00 +0000

The four patterns of AI-native development, presented at TechRocks Paris. This version covers the full framework plus an extended Q&A on how AI changes developer culture, the cost of agent swarms, and why documentation matters more than ever.

The transformation is the same

Every technology transformation — DevOps, cloud, agile — follows the same adoption arc: find enthusiasts, nurture one team, remove their bottlenecks, synthesize learnings, scale across the organization. AI is no different. The tooling is new, the transformation process isn’t.

7 Learnings from the AI Engineer's World Fair

Tue, 17 Jun 2025 00:00:00 +0000

Lessons from the AI Engineer’s World Fair on software engineering with AI:

AI coding agents are ubiquitous — across every development environment
Tool usage requires constant evolution — applying six-month-old approaches is already counterproductive
Specifications now rival code in importance — structured intent beats ad-hoc prompting
Agents span multiple domains — from IDEs to cloud infrastructure
Parallel execution enables parallel exploration — not just faster, but fundamentally different
CI/CD processes are shifting left with AI integration
Realistic expectations about AI delivery matter for planning

The quote that stuck

Matthew Skelton captured it best: “Prompting is sorta dead, in the next level you’ll be writing specifications.” Specifications persist while prompts are ephemeral. They function as structured human-machine communication. Tests make specifications executable and verifiable.

Not All Bug Fixes Are Equal

Thu, 12 Jun 2025 00:00:00 +0000

Not all bug fixes are equal: there are those LLMs can solve and then there are those developers don’t want to hear about.

Credit to Tomas Reimers for the observation. It’s funny because it’s true — and it maps to a real categorization problem. The bugs AI handles well are the ones with clear patterns: syntax errors, known library issues, standard implementation mistakes. The ones developers avoid are the architectural ones, the “we made this decision three years ago and now it haunts us” ones.

The 4 Patterns of AI Native Development

Wed, 04 Jun 2025 00:00:00 +0000

In this presentation, Patrick Debois lays out a framework for understanding how generative AI is transforming software development beyond faster typing. He opens by mapping the technology explosion — from basic LLM completions through RAG, function calling (now MCP), autonomous agents, and emerging teams of agents — and draws a parallel with cloud native: just as moving to the cloud meant more than migrating VMs, AI native development means fundamentally new practices, not just AI sprinkled on existing workflows. Every new technology reshapes tasks, making some obsolete, enhancing others, and creating entirely new ones. Patrick distills these shifts into four patterns.

4 Patterns of AI Native Development — Stockholm Edition

Mon, 02 Jun 2025 00:00:00 +0000

Presented at the AI Native Dev meetup in Stockholm, Patrick Debois traces the rapid evolution of AI coding tools — from simple autocomplete copilots through chat interfaces, codebase-aware editors, multi-file agents, and now headless CLI-based agent swarms running asynchronously in the background. He frames this progression against the concept of “AI native” development: not just sprinkling AI on top of existing workflows, but fundamentally rethinking how developers work, much as cloud native meant more than lifting VMs into the cloud.

On AI and DevOps: What's Next?

Tue, 22 Apr 2025 00:00:00 +0000

In this podcast conversation, Patrick discusses his journey from DevOps pioneer to generative AI practitioner, tracing how his interest in virtual production and automated media during the pandemic eventually led him into the world of large language models and code generation. He reflects on the DevOps Handbook, noting that while its core principles remain valid, the industry landscape has evolved significantly since its publication.

Copilot's Quiet Comeback: GitHub's AI Tool Isn't Done Yet

Thu, 10 Apr 2025 00:00:00 +0000

I took the time to summarize GitHub Copilot’s upcoming capabilities — specifically prompt management, Agent mode, and MCP tools extension support. The question: is this enough for GitHub to maintain its competitive advantage in the enterprise market?

What’s changed

Prompt Management — Three-tier system: global custom instructions in .github/copilot-instructions.md, action-specific instructions for different tasks (code generation, testing, commits), and reusable prompt snippets stored in .github/prompts.

Agent Mode — Autonomous reasoning capabilities with continuous conversation, code planning, and model flexibility including Claude 3.5 alternatives. This was the piece that was previously missing.

Four Patterns of AI Native Dev: From Content Creation to Knowledge

Tue, 08 Apr 2025 00:00:00 +0000

Pattern #4 and final pattern in the Four Patterns of AI Native Development series. AI is transforming how organizations capture, preserve, and leverage knowledge — from unstructured content into actionable intelligence.

AI reads what humans won’t

While humans struggle to consume documentation, AI reads it effectively. Organizations accumulate vast knowledge across emails, chat messages, pull requests, and incident reports. Rather than forcing developers to navigate outdated wikis, AI can surface relevant context inline, improving code suggestions while keeping documentation current.

Four Patterns of AI Native Dev: From Delivery to Discovery

Sat, 05 Apr 2025 00:00:00 +0000

Pattern #3 in the Four Patterns of AI Native Development series. As AI handles coding tasks, developers shift from delivery-focused work to discovery and exploration — building products that better serve customer needs.

Building the right things

With AI automating code generation, teams can collaborate more on “building the right thing” rather than just “building the thing right.” With affordable compute, we can leverage AI to generate and deliver multiple ideas simultaneously, accelerating feedback loops and product validation.

Four Patterns of AI Native Dev: From Implementation to Intent

Thu, 03 Apr 2025 00:00:00 +0000

Pattern #2 in the Four Patterns of AI Native Development series. The better AI becomes, the less we need to focus on the implementation and can work on describing the intent. This shift can happen through chat conversations or product requirement documents — creating a central collaborative space.

The evolution

Development has progressively abstracted away from low-level operations. Where programmers once manipulated switches and machine code, they now use natural language prompts. The LLM, like a compiler, translates our thoughts into code.

Intent-Driven Development — Tessl Podcast

Wed, 26 Mar 2025 00:00:00 +0000

In this episode of the AI Native Dev podcast hosted by Tessl, Patrick joins Simon Maple for an in-depth conversation about the emerging patterns of AI-native development. They begin by discussing what constitutes a paradigm shift – not merely adding AI on top of existing workflows, but fundamentally rethinking how software is built. Patrick draws parallels to previous shifts like cloud native and DevOps, noting that the sheer number of unknowns, the creation of new job roles, and the need to rethink established processes are hallmarks of a genuine paradigm change.

Above or Below the Algorithm?

Tue, 25 Mar 2025 00:00:00 +0000

“Are you gonna be working above or below the algorithm?” — Jan Bosch at the Future of Software event hosted by Eficode.

A provocation worth sitting with. As AI capabilities expand, some developers will work above the algorithm — directing, orchestrating, deciding what to build. Others will work below — implementing, debugging, maintaining the systems that AI relies on.

The lack of reaction in the room when Jan posed this proved his point about developers and feelings. The question isn’t comfortable, but it’s the right one to ask.

Four Patterns of AI Native Dev: From Producer to Manager

Tue, 25 Mar 2025 00:00:00 +0000

Pattern #1 in the Four Patterns of AI Native Development series. The trend is clear: the more AI generates, the bigger the pull requests become. Developers are shifting from code producers to code reviewers and decision-makers.

AI produces, you review

What began with simple IDE autocompletion has evolved into AI generating complete application scaffolding. Developers now spend less time writing and more time validating AI-generated code — mirroring traditional peer code review, but at a different scale.

The AI Native Dev Landscape

Tue, 25 Mar 2025 00:00:00 +0000

We built an overview of the AI Native Dev landscape. No more FOMO on discovering tools.

The AI-native development space is moving fast — new tools, new categories, new approaches every week. Keeping track of what exists and where it fits became a real problem. So we created a comprehensive landscape to map it all out.

The response was immediate: 40+ additional tools were submitted right after launch, confirming that discovery is a genuine pain point. The community wants a shared map.

The Future of Audio AI: Insights from ElevenLabs

Thu, 27 Feb 2025 00:00:00 +0000

Mati Staniszewski (ElevenLabs co-founder) in conversation with Guy Podjarny on technical scaling challenges and organizational design philosophy at ElevenLabs.

The standout insight: ElevenLabs runs a “titleless organisation” designed to enable employees to reach their full potential and impact regardless of title. An interesting experiment in organizational structure that connects to broader questions about how AI companies organize differently.

Worth watching for the intersection of technical scaling challenges, audio AI development, and unconventional organizational design.

Reverse Conway's Law and Agents

Sat, 22 Feb 2025 00:00:00 +0000

My talk at the AI Engineer conference is online: “Reverse Conway’s law and GenAI: How agents will take over the organisation.” The clickbait title wasn’t mine — but the talk examines possible futures for how agents can “infiltrate” our teams and organisations.

Conway’s Law says organizations design systems that mirror their communication structures. The reverse question: as AI agents become part of the team, how do they reshape the organization itself?

Coding Agents Are Hot: Notes from AI Engineer NYC

Fri, 21 Feb 2025 00:00:00 +0000

While attending the AI Engineer’s NYC Summit, I noticed a trend: while last year everyone was trying to sell you a vector database, evals are now the rage.

What I saw

Sourcegraph & Booking.com — Migration automation and review systems
Datadog — SRE/DevOps agent announcements alongside evals work
Daytona — Sandbox for agent code generation
Gitpod — Development environment automation
Ellipsis Development — PR review system with agent integration
Windsurf — Autonomous coding agent advances

The market is early-stage despite rapid innovation. The shift from vector databases to evals signals a maturing industry — people are past “can AI code?” and onto “how do we know if the code is good?”

Researching AI Native Dev Manifestos

Wed, 12 Feb 2025 00:00:00 +0000

Researching AI Native Development manifestos — what makes it different now? How are we thinking and operating differently?

Here’s what I found:

I find it hard to see emerging practices for something we’ve only been doing for a short period of time. Is it too soon? Or is the speed of change itself the reason we need frameworks to think about it?

AI Native Development: Discovering Patterns — AUTONOMOUS Conference

Fri, 07 Feb 2025 00:00:00 +0000

Patrick presents a work-in-progress overview of AI-native development patterns at the AUTONOMOUS Conference, structured around four stages of increasing abstraction: delegated coding, specification-driven development, context enrichment, and building trust for autonomous operation. He opens with a rapid walkthrough of how coding tools have evolved – from single-line completions to chat-driven generation, multi-file edits, terminal and browser feedback loops, test generation, reasoning models, and eventually continuous autonomous loops like Devin with multiple agents working in parallel.

Discovering AI Native Development Patterns

Fri, 07 Feb 2025 00:00:00 +0000

Video of my talk at the AUTONOMOUS summit is now online. A short watch with lots of information about the big blocks that can help you focus more on the why vs the how in this tool-centric world.

The five patterns

Delegated coding — where most tools are focusing. Better assisted coding loop, ultimately autonomous.
Specification-centric development — moving from the code to the specification or intent we want to build.
Delegating trust — how will these systems gain our trust?
Context awareness — all systems live in a context from IDE to production environment all the way up to business context.
Human oversight — this technology is inherently error prone. How can humans deal with it when needed?

This is all work in progress, and part of work with the ainativedev.io community.

It Is Not Just About the LLMs Anymore

Thu, 06 Feb 2025 00:00:00 +0000

It is not just about the LLMs anymore. The industry has evolved beyond Large Language Models to include orchestration, integration, and specialized capabilities. Not everyone will end up on the right side — diminishing returns are real — but commoditization will drive accessibility and affordability.

What I find particularly interesting is the “toolforming” phase: where agents autonomously create new tools to accomplish their missions. This goes beyond using existing tools — agents building their own tools to solve problems they encounter.

How Do You Evaluate AI Coding Tools?

Tue, 04 Feb 2025 00:00:00 +0000

How do you evaluate these new AI coding tools? Why do you like Cursor, Lovable, Windsurf, Bolt, v0 etc more than others?

Functional features to consider

Chat, code completion, or multifile generation capabilities
Ability to examine code, tests, terminal and browser errors
IDE and tooling ecosystem compatibility
Navigation assistance for code edits
Custom LLM integration options
Support for coding style and component requirements
Context addition from documentation, tickets, and telemetry
Learning knowledge tracking

Performance metrics

Code suggestion quality and longevity in codebase
Autonomy level and human-AI intervention requirements
Code comprehensibility and debuggability
Implementation flexibility versus specification-driven approaches

Or is it all vibe checks?

Continuous Coding Pipeline

Wed, 18 Dec 2024 00:00:00 +0000

“Continuous Coding Pipeline”: infra that sits next to the traditional CI/CD pipeline, for automated coding agents.

The naming question sparked great discussion. Alternative suggestions included:

Agent-Driven Development Infrastructure (ADI)
Continuous Agentic Code Integration
Autonomous Development Infrastructure
The “limitation finder” (near term) / “autonomous code” (long term)
Continuous Merge

The point isn’t the name — it’s that this is emerging as a distinct infrastructure concern. Just as CI/CD became its own category separate from build systems, the infrastructure for automated coding agents is becoming its own thing. It’s not traditional CI/CD. It’s something new.

My 2024 GenAI and DevOps Perspective Journey

Thu, 12 Dec 2024 00:00:00 +0000

A collection of five talks documenting my two-year focus on generative AI and DevOps. The narrative evolved from “genAI in the product” toward examining organizational and people-centered impacts on the software development lifecycle. The talks are dense with lots of references and research.

The five talks

From ChatGPT to Production — Delivering GenAI applications using DevOps principles: testing, observability, security. The DevOps Conference.
AI Platform Engineering — Scaling GenAI across organizations from proof-of-concept to platform teams. AI Engineer Summit.

Boosters for AI Native Development

Fri, 06 Dec 2024 00:00:00 +0000

What can organisations do to improve the effect of AI tooling such as Copilot, Cursor, Bolt.new?

The key insight: to go faster with AI you have to have your house in order. The better information you feed it, the better it will help you. AI coding tools attempt to gather extensive context — documentation, test coverage, APIs, designs, requirements, incidents, and runbooks — to provide optimal results.

Organizations must rethink processes, standardize tooling, and prioritize knowledge capture. Digital transformation lessons show that tools alone have limited impact; comprehensive process and workflow examination drives real change.

Conway's Law and GenAI: Evolving Your Organisation Design

Mon, 25 Nov 2024 00:00:00 +0000

Patrick Debois presents a thought-provoking exploration of how generative AI may reshape organizational structures through the lens of Conway’s Law – the principle that organizations design systems mirroring their own communication structures. Delivered at the “AI for the Rest of Us” event, the talk deliberately avoids deep technology discussion in favor of examining the human and organizational implications of AI adoption that apply across any role or department.

From GitHub Copilot to AI Native Development

Sat, 23 Nov 2024 00:00:00 +0000

Patrick surveys the rapidly evolving landscape of AI-powered coding tools, tracing the journey from basic tab-completion in GitHub Copilot to a fundamentally new way of developing software. He demonstrates how features like instant apply, multi-line edits, predictive cursor jumps, bring-your-own-model support, and reasoning-based architecture planning have transformed the IDE experience. Multi-file editing, pioneered by Cursor, marked a particularly significant leap, allowing developers to issue a single prompt and see changes propagated across an entire codebase.

AI Can't Touch This: Lock Files for AI Coding Agents

Thu, 21 Nov 2024 00:00:00 +0000

Spotted a new “lock file” pattern in AI coding IDEs like Bolt.new — a way to protect files (like specifications) from being rewritten by AI agents. Is this the beginning of ACLs specific for AI coding agents?

The comments went interesting places. Matthew Skelton warned about reinventing problematic file locking from Visual Source Safe. Matthias Lubken suggested expanding beyond pure ACLs to include hints like “avoid changes,” “never change,” “refactor when possible,” and “always performance test.” Ray Myers argued it should default to opt-in rather than opt-out.

Extending OpenTelemetry to Pinpoint Code Elements

Thu, 21 Nov 2024 00:00:00 +0000

Using OpenTelemetry to better pinpoint parts of the code in case of issues. A nice writeup by the folks from Baz on extending OpenTelemetry to close the gap between production issues and code elements.

What excites me about this: production feedback mechanisms that improve AI coding tools. If we can trace from production incidents back to specific code elements, that’s exactly the kind of context AI coding tools need to get better.

A Transpiler from One Infrastructure as Code to Another

Sun, 10 Nov 2024 00:00:00 +0000

Current thought: a transpiler from one infrastructure as code language to another… how hard can it be?

The comments revealed the full spectrum of opinions. Some pointed to existing bridges (Pulumi’s Terraform bridge), others questioned the ROI entirely. Nathan Peck noted that with generative AI, it “mostly just works out of the box already.” Bill Bensing asked the harder question: if you need transpilers, why not just use a limited toolset?

What Is a Product Engineer (and Why They're Awesome)

Thu, 31 Oct 2024 00:00:00 +0000

“You don’t really fit our org chart” — a comment I frequently receive when describing my desired role.

The concept of “Product Engineer” captures something important: engineers who have a thirst for using technologies to leapfrog human/user problems. Those with empathy to reach for magical experiences. That’s Jean-Michel Lemieux (former VP of Engineering at Shopify) describing what these roles look like.

Product engineering sits at the intersection of technical expertise and end-user focus. Not purely a developer, not purely a product manager, not purely a designer — but someone who bridges all three.

SRE Race Against the AI

Thu, 24 Oct 2024 00:00:00 +0000

SRE Bench Race — how AI will gamify us into learning and gather more data.

An interesting approach to training SRE skills by racing against AI. The team behind it built it in about 2 days, and the community response suggests appetite for more use-case-specific modules.

The deeper pattern: using AI competition as a learning mechanism. Rather than replacing SREs, creating a game where humans and AI compete on the same tasks — which simultaneously trains humans and generates training data.

AiRE: AI Reliability Engineer

Tue, 22 Oct 2024 00:00:00 +0000

Saw the term “AiRE” today — AI Reliability Engineer. Who coined this?

Turns out it traces back to Denys Vasyliev, with Liz Fong-Jones crediting Todd Underwood as “the original AiRE.”

The comments revealed the tension: Phil Calcado questioned whether this truly differs from existing distributed systems engineering practices. Oliver Leaver-Smith joked about having ChatGPT and Perplexity as a warm spare. The skepticism is fair — but the naming matters because it signals a shift in what reliability means when AI is in the loop.

Speculative Design: We Cannot Work Towards What We Cannot Imagine

Tue, 22 Oct 2024 00:00:00 +0000

Discovered “Speculative Design” — a framework I hadn’t encountered before. The quote captures it perfectly: “We cannot work towards an improvement that we cannot imagine” — Elise Boulding.

It’s like Conway’s Law applied to innovation: your ability to improve is constrained by your ability to envision something different. Speculative Design gives you tools to imagine beyond current constraints.

The comments went deep: Russell Smiley on how change requires visualizing different possibilities, John Sullivan on his “Death Star” thought experiment about building at massive scale, and Doug Finke with Einstein on imagination.

How AI Agents Rewire the Organization

Sun, 20 Oct 2024 00:00:00 +0000

“AI won’t eat your job, but it will eat your salary.”

Sangeet Paul Choudary captures the distinction that matters: “Agents are goal-seeking, and that’s what makes them different. While most technology aims at task substitution, agents go beyond tasks to seek goals.”

This is the organizational rewiring in action. When agents are goal-seeking rather than just task-executing, they don’t just slot into existing roles — they reshape the structure around them. The question isn’t which jobs disappear, but how the whole organization changes when parts of it become autonomous.

The Rise of Software-Delivered Services

Sun, 20 Oct 2024 00:00:00 +0000

Learned about “Software-Delivered Services (SDS)” and “Service-as-a-Software” — a reframing of how software companies deliver value.

The key business question Tracy Bannon raised in the comments: “How do they bill for this new thing?” When software doesn’t just enable a service but delivers it directly, the traditional SaaS billing model doesn’t quite fit.

This connects to the broader AI-native development story: as AI agents can deliver services autonomously, the line between “software product” and “service delivery” blurs entirely.

Conferences Should Find More Practitioners vs Preachers

Fri, 18 Oct 2024 00:00:00 +0000

Conferences should find more practitioners vs preachers. EOM.

This struck a nerve (125 likes, 27 comments). The structural barriers are real: David Sandilands noted enterprises don’t allow their people to talk about what they’re working on, resulting in vendor-dominated lineups. Sasha Czarkowski captured it perfectly: “The practitioners are too busy practicing.”

Solutions exist: DevEx Connect focuses on practitioners and local stories. ProveIt! Conference is exclusively practitioner-focused. And the devopsdays model — which I know well — gets its value from open spaces where everyone participates.

Generative AI Is Changing Our Jobs — DevOpsDays London 2024

Fri, 04 Oct 2024 00:00:00 +0000

Patrick opens with a live demonstration of Cursor, a new-generation coding editor, where he provides a markdown specification describing the desired frontend, backend, API, and directory structure — and the tool generates the entire application in minutes. This sets the stage for the core argument: AI is moving beyond ghost-text completion and chat sidebars toward specification-driven, plan-and-execute workflows that fundamentally change what developers spend their time on.

Every AI Engineer Deserves a Platform — ETLS Edition

Tue, 24 Sep 2024 00:00:00 +0000

Patrick argues that GenAI technology, much like cloud before it, needs a dedicated platform team to scale effectively across an organization. Drawing on his experience as a VP of Engineering at Showpad, where he helped bring AI features to market, he outlines a three-part framework: platform infrastructure, enablement, and governance. The talk was presented at ETLS, introduced by Gene Kim who describes Patrick as “the Godfather of DevOps.”

AI Platform Engineering — AI Engineer Summit

Mon, 26 Aug 2024 00:00:00 +0000

Patrick draws on his 15 years of DevOps experience — starting from organizing the first DevOpsDays in 2009 — to frame how organizations should approach scaling generative AI. He traces a familiar pattern: a pilot team experiments with new technology, learnings are extracted, and eventually an abstraction layer (a platform) emerges so that other teams can move faster without having to understand every underlying detail. The same progression that played out with cloud infrastructure and DevOps is now repeating with AI engineering.

Scaling Success: The Role of GenAI in Modern DevOps with a Platform Team

Mon, 26 Aug 2024 00:00:00 +0000

This three-part webinar, hosted by PerfectScale, covers the full spectrum of how GenAI and DevOps intersect. Patrick Debois presents a comprehensive framework for scaling generative AI across an organization using platform team principles, examines how AI-powered tooling is transforming the daily work of engineers, and speculates on how autonomous agents may reshape organizational structures.

AI Platform - The Artificially Intelligent Enterprise Online Conference