PODCAST EPISODE 133

Your Software Factory Needs a Bill of Materials | Daniel Meppiel

Microsoft's Daniel Meppiel on why developers will write skills, not code, and what it takes to version and trust the software factory that runs them.

19 Nov 202601 h 01 min

Transcript

In this episode

Developers are about to write skills instead of code, and Microsoft's Daniel Meppiel argues the software factory that runs them needs versioning, a bill of materials and signed receipts before enterprises will trust it.

Watch all the AI DevCon NYC 2026 talks:
https://tessl.co/7jw

Recorded live at AI DevCon NYC 2026, Simon Maple sits down with Daniel, of Microsoft's Global Black Belt team and creator of APM (Agent Package Manager), to dig into why teams keep rebuilding the same skills, how to version a skill when the change is in its behavior rather than a method signature, and why skills can only ever be guidance while security controls stay deterministic. Then stay for Daniel's full DevCon talk, Version Your Factory, Not Just Your Code, on agent contracts, signed receipts and the evidence a regulated enterprise needs before it auto-merges.

What we cover:

  • Why developers will write skills and prose instead of code
  • Why teams keep rebuilding the same skills, and the case for a shared skill catalog
  • Testing and versioning skills with evals: when is a change a major version?
  • APM, lock files and an agent bill of materials for your software factory
  • Skills are guidance, security controls are deterministic
  • Daniel's AI DevCon talk: agent contracts, signed receipts and auto-merging on evidence

Chapters:

00:00:00 - Introduction

00:02:53 - Why developers will write skills, not code

00:05:49 - Why teams keep rebuilding the same skills

00:07:52 - Versioning the software factory, not just the code

00:09:48 - Testing and versioning skills with evals

00:14:09 - APM and the agent bill of materials

00:17:44 - Skills are guidance, controls are deterministic

00:21:02 - Skill catalogs, governance and measuring impact

00:24:46 - What developers do once the factory runs

00:28:08 - AI DevCon talk: Version Your Factory, Not Just Your Code

Book early for AI DevCon London 2027, 7–8 June at The Brewery, Moorgate:
https://tessl.co/wzi

🔔 Subscribe for weekly episodes on AI-native development

Would you let your software factory auto-merge on evidence alone? Tell us in the comments.

If developers stop writing code and start writing skills, the software factory that runs those skills becomes the thing that needs engineering discipline. That shift appears to be well underway, but the practices that made traditional software trustworthy, such as versioning, lock files and bills of materials, have mostly not followed it yet.

Daniel Meppiel works in Microsoft's Global Black Belt team, helping some of the largest enterprises adopt AI across the software development lifecycle, and he created APM, the Agent Package Manager. Simon Maple sat down with him at AI DevCon NYC 2026, and the episode closes with Daniel's full conference talk, Version Your Factory, Not Just Your Code.

From writing code to writing skills

Daniel's starting point is direct. "We are not going to be writing code anymore," he said. What developers write instead is prose: skills, prompts and other natural language modules that aim to get reliable behavior out of a variable system. Put enough of those together with a trigger and some verification and you have what the industry is calling a software factory.

He frames this as a new programming paradigm, which is useful because it suggests the old practices still apply. Skills, hooks and MCP servers are what he calls agentic primitives, hooked onto the harness so that agents produce outputs teams can trust in production. Building that layer deserves the same rigor that once went into the code itself.

The skill sprawl problem

The most common failure Daniel sees in large organizations is not a bad skill. It is the same skill being rebuilt again and again. Teams in Europe, the US and Asia each discover that encoding their knowledge into skills delivers real productivity gains, and each builds their own version on their own laptops.

His recommended first step is a shared catalog where everyone can read, improve and source skills, creating an inner-source motion around them. The second is governance: policies that say which skills must be present for a given project and which are not allowed. He sees the platform team spearheading this, with policies that cascade from organization to team to repository, much as platform engineering already works today.

How do you version an agent skill?

Versioning a skill means detecting when a change alters its behavior rather than just its wording. A minor version moves the skill further in the same direction; a major version changes the direction, the output, or what users of that skill must do. In practice, that requires evals that run on every skill change and can show the deviation.

That is the theory. The reality, Daniel noted, is that the industry has not figured this out yet. Of the customers he works with, he observed, "I still don't see them rigorously and systematically evaluating their skills." Until evals become commonplace, there is no reliable way to say a change is version 2.0 rather than 1.1.

Testing itself splits into two families. Deterministic unit and integration tests remain essential, because they are what give teams the confidence to ship. Alongside them, model-based reviews add value by catching vulnerabilities or regulatory issues that deterministic engines cannot, even if they cannot carry the same level of trust.

Guidance versus controls

Simon pushed on an uncomfortable truth: an agent will sometimes follow a skill only loosely. Daniel was clear that this is inherent. "The skills are always guidance," he said, even if a rule is written in capitals or repeated ten times.

His analogy is hiring. You interview someone because they already have the skills you need, but you still give them a badge to enter the building and a laptop with security controls. Agents work the same way. Skills shape the role, the process and the taste. Runtime governance, sandboxes and permissions are the badge, and those have to be deterministic.

Building a fabric of trust for agentic software factories

Daniel's talk takes this into the regulated enterprise. Imagine a bank whose factory produces a pull request that changes how wire payments are approved. Would anyone auto-merge it? Today, almost certainly not, and a risk classifier on its own does not change that answer.

His argument is that classic software earned trust through a layered fabric, and "it all starts with versioning," because versioning gives an artifact an identity. Inventories, provenance, evidence, signatures and admission checks build on top of that. To recreate it for factories, he proposes agent contracts: simple Markdown files that define the role, dependencies, budget and checks for a single unit of agent work, chained together into a versioned factory that can run on any harness.

Each run then produces a signed receipt that ties the output back to the factory version, the check results and an agent bill of materials drawn from the APM lock file. A gate in CI, such as `apm audit`, checks that receipt against policy before anything merges. Because the checks live in the contracts and are cryptographically tied to the receipt, an agent cannot quietly weaken them. When a skill turns out to be compromised, the receipts show which factories used it.

It can be helpful to read this as a shift from confidence to evidence. Rather than trusting a factory because a smart engineer vouches for it, the organization trusts it because the record proves what ran, with which skills, under which rules.

Whether your team is still sharing skills over chat or already thinking about auto-merge, the conversation is worth a listen, and Daniel's full DevCon talk is included at the end. What would your organization need to see before it trusted a factory's pull request?

CHAPTERS