Insights.
Thinking on software identity, agentic development, and the engineering decisions that persist.
Atlassian Rovo Dev CLI + Ribo: DNA at the Command Line
Rovo Dev CLI runs agentic workflows from the terminal, tied to Jira tickets. Wire Ribo in via MCP and each ticket gets executed against the system's declared identity, not just the ticket's prose.
No articles in this category yet.
Atlassian Rovo Dev CLI + Ribo: DNA at the Command Line
Rovo Dev CLI runs agentic workflows from the terminal, tied to Jira tickets. Wire Ribo in via MCP and each ticket gets executed against the system's declared identity, not just the ticket's prose.
ChatGPT + Ribo: Ask Across Tools Without Losing the Thread of Intent
ChatGPT's MCP connectors let a single chat pull context from every system your team uses. Adding Ribo means every cross-tool answer lands against your declared intent instead of against generic best practice.
Claude Code + Ribo: One Truth, Every Subagent
Claude Code spawns subagents, runs skills, chains commands. Wire Ribo in via MCP and every one of them reads against the same declared source of truth.
Claude + Ribo: Your Cross-Tool Cockpit, Anchored to Intent
Claude's chat app now connects to remote MCP servers. Plug Ribo in and every question you ask across Linear, Jira, Sentry, and Intercom gets answered against your system's declared identity.
CodeRabbit + Ribo: PR Review Against Intent, Not Just Diff Hygiene
Wire Ribo into CodeRabbit as an MCP server and the PR reviewer gains a scoped, auditable view of your system's declared intent. Review becomes citation, not opinion.
Cursor Completes Code. Ribo Tells It What the System Is.
Hook Ribo into Cursor as an MCP server and the IDE's completions stop guessing at your architecture. They complete against your declared intent, contracts, and constraints.
GitHub Actions + Ribo: Gate Merges on DNA Conformance
GitHub Actions has no first-party MCP client. The pattern that works: run Claude Code as a workflow step with Ribo mounted, and make DNA conformance a required check before merge.
GitHub Copilot + Ribo: Suggestions That Respect Your DNA
Copilot runs in two modes: IDE completions on your laptop and a coding agent on GitHub's servers that opens PRs. Wire Ribo into both via MCP and both stop reasoning from scratch.
Intercom Fin + Ribo: Answers Grounded in Product Intent
Fin pulls answers from your documentation. Wire Ribo in as a custom MCP connector and Fin starts citing your product's declared intent instead of whatever your help center happens to say.
Windsurf + Ribo: Cascade Inside the Intent Envelope
Windsurf's Cascade runs long, multi-step write sessions. Hook Ribo in via MCP and every step reasons against the declared shape of the system, not just the files in view.
Your Agents Rediscover Your Codebase Every Query
Karpathy's LLM Wiki and Nate B. Jones's Open Brain are making a fork visible in personal memory: compile at write time, or query at demand. The same fork runs through software identity. Here is how we are working on it one layer up.
Zendesk + Ribo: Support Replies Grounded in Declared Behavior
Zendesk's AI Agents are moving to an MCP-native architecture. When the MCP Client ships, Ribo is the connector that anchors every automated reply to your system's declared intent, not to stale knowledge base articles.
Ask Upstream. Converge Downstream.
Agents guess because you gave them nowhere to ask. A source of truth they can defer to, a channel they can use when the truth is incomplete, and a fleet of narrow downstream passes does the rest.
One Call to Know. Not Ten to Guess.
Every turn an agent spends rediscovering what a function is, who owns it, and what it promises is a tax on your latency, your token bill, and your error rate. The fix is not more context. It is identity upstream of discovery.
The Bottleneck Flipped
In 2025, the hard problem was finding enough context for agents. In 2026, the hard problem is finding less of it. When identity exists upstream, the new skill is slicing -- carving the smallest coherent cross-section of DNA that contains all the concerns for a given task.
Adopt Identity Engineering Without Stopping the Roadmap
The biggest fear CTOs have about identity engineering is that it requires pausing feature work. It doesn't. The strangler fig pattern lets you start with one service, prove the value in a single quarter, and expand without stopping the roadmap.
Three Ways to Screw Up Identity Engineering
Identity engineering has real failure modes. Teams that adopt it badly end up worse than teams that never adopted it at all. This article names the three most common ways it goes wrong and the antidote for each.
What Identity Gaps Actually Cost Your Engineering Org
Identity gaps have a dollar cost. Not a vague 'technical debt' cost -- an actual, calculable cost per quarter that shows up in onboarding delays, incident duration, review bottlenecks, agent rejection rates, and compliance overhead. Here is the model to calculate it for your own org.
The Numbers After Identity Engineering
Teams that declared what their software is supposed to be, then measured against it, keep reporting the same pattern: onboarding cuts in half, production outages drop to near zero, deploy frequency doubles. These are the closest real-world numbers we have for identity engineering, and they tell a consistent story.
Where Identity Engineering Fits in Your Sprint
Identity engineering has to fit into the workflow you already have or it will be rejected. This article maps exactly where identity declarations get created, reviewed, and updated within the sprint cycle, PR workflow, CI/CD pipeline, and incident response.
You Already Have Half an Identity Layer
Most engineering teams already have fragments of an identity layer scattered across Backstage, OpenAPI, Terraform, CLAUDE.md, ADRs, and K8s manifests. The problem isn't that you have no identity layer. It's that you have half of one, fragmented across tools that don't talk to each other, with critical gaps between them.
The Organ That Kills 97% of Its Own Output
Your immune system eliminates almost every T-cell it produces -- not for being broken, but for failing an identity check. Software teams pentest behavior but almost never pentest identity. That gap is where the hardest bugs live.
The Bug Nobody Wrote
45% of software defects originate before anyone writes a line of code. You can't catch them with better tests because the tests inherit the same blind spots as the spec. The fix is testing upstream: probing what the software claims to be, not just what it does.
What Slime Mold Knows About Software Architecture
Biological systems converge on optimal solutions because their targets have shape. Slogans don't converge. Specific, measurable identity declarations do. The difference determines whether your agent fleet finds the architecture or wanders forever.
Agents Converge the Same Way Models Do
A fleet of agents editing a codebase is a learning system whether you designed it that way or not. Without a declared identity, there is no loss function, and nothing converges.
Same DNA, Native Everywhere: Why Cross-Platform Was the Wrong Abstraction
The industry answered 'two platforms, one product' by sharing code. But the thing that needed sharing was never code — it was identity. When identity is the source of truth and each platform has its own ribosome layer, you get two fully native codebases that honor the same contracts, run independent experiments, and cost tokens instead of headcount.
Eight Laws from 1974 That Predicted the Need for Software DNA
In 1974, Meir Lehman formulated laws of software evolution that describe how real-world systems inevitably change, grow complex, and decline. For fifty years, humans were the only mechanism for honoring those laws. Identity engineering is the first architecture that can honor them at the speed they actually demand.
The Ribosome Layer: Where Identity Becomes Code
Between what your software should be and the code that runs, there's a translation layer the industry never named. It determines the language, the frameworks, the quality constraints, and the idioms. We call it the Ribosome Layer, because that's what ribosomes do: read instructions and produce functional output given available materials and environmental constraints.
Every Developer Has a Different AI. That's the Problem.
Your team uses six different AI setups across five editors with four models and three rules file formats. The same ticket produces wildly different code depending on who picks it up. Standardizing tools won't fix this. An identity layer will.
The Brand Moved. The Code Didn't.
Every company eventually repositions. Marketing updates the website in days. Sales starts pitching the new story in weeks. The codebase is still what it was yesterday. Here's how to close the gap between what your company says it is and what the software actually does.
The DNA-First Organization
The traditional org was designed around code production. An identity-first org is designed around trust production. Here's what changes for product, engineering, compliance, marketing, support, and ops when the identity layer becomes the center.
Prioritizing the Delta: What to Reconcile First
You can see the gap between what your software declares and what it actually does. Now you need a system for deciding what to fix first. Here is one.
Reconcile, Don't Generate. The Lesson Every Declarative System Had to Learn.
MDA tried to generate code from declarations and failed. Identity engineering reconciles code against declarations — a structurally different pattern with a proven track record in infrastructure.
Your Software Is Never Done. That's the Point.
Burndown charts assume a fixed destination. But software identity is a moving target. The metric that matters isn't whether you hit zero — it's the rate at which your system converges toward what it's supposed to be right now.
Identity Engineering Doesn't Replace Product Discovery
The strongest objection to identity engineering is that a wrong identity faithfully enforced is worse than no identity at all. The objection is correct. That's why the humans defining it carry the hardest job.
Reconciliation Is Probabilistic, and That's the Point
The sharpest objection to identity engineering is that you can't formally verify code against natural-language constraints. That's true. It's also irrelevant. Every quality mechanism in software is probabilistic. Reconciliation just needs to be better than nothing.
Code Was Never the Source of Truth. It Just Outlived Everything Else.
Specs drifted. Docs rotted. Tribal knowledge walked out the door. The code became the source of truth by default -- not because it's good at the job, but because everything else died first.
You Don't Need More Engineers. You Need an Identity Layer.
Spec-driven development produces documents that drift. Identity engineering produces a living layer that agents reconcile against continuously. The shift isn't technological — it's organizational. Here's what the operating model actually looks like.
What the Amazon AI Outage Actually Proved
Amazon's fix was more review gates. That doesn't scale. The real lesson: AI agents need something to reconcile against before they touch production.
Twelve Months from 'Forget the Code' to 'Spec or Die'
February 2025: vibe coding. February 2026: agentic engineering. The fastest paradigm shift in modern software, month by month.
The Next Decade Looks More Like Terraform Than GitHub
Terraform proved infrastructure should be declared. The same transformation is coming to application software. The specification becomes the source of truth.
The Three Debts AI Is Creating (Only One Is About Code)
Everyone's talking about AI code quality. The actual problem is cognitive debt, verification debt, and architectural debt, and your linter can't catch any of them.
8,000 Startups Need a Rebuild
The first wave of vibe-coded startups is hitting a wall. The survivors won't be the ones who abandoned AI. They'll be the ones who defined what their software is before they let AI build it.
The Compliance Time Bomb in Your AI-Generated Code
EU AI Act enforcement hits August 2026. Colorado's AI Act hits June 2026. Most engineering orgs have zero governance for AI-generated code. The audit is coming.
Rewrite Everything. Lose Nothing.
AI is making rewrites cheap. But 70% still fail. The code is disposable. The contracts are not.
The Truth Layer Needs Infrastructure, Not Just Documents
Bill Eisenhauer proposed that specifications are the durable artifact and code is a regenerable rendering. The natural next question: what does the infrastructure look like that makes that work at enterprise scale?
Declare Your Compliance Once. Be Compliant Forever.
Every compliance tool tells you you're broken. None of them fix it. What if a single declaration triggered automatic, codebase-wide reconciliation?
How to Build an Engineering Org for the Agent Era
If you were hiring today knowing AI writes 41% of the code, would you build the same org? The roles, the teams, the governance -- it all changes.
How to Audit AI-Generated Code for Compliance
Your auditor will ask who wrote the code, against what specification, and how you verified it. Here's how to have answers.
How to Write Specs That AI Agents Actually Follow
You wrote a spec. Your AI agent ignored it. Here is why, and how to write specifications that agents actually respect.
One Truth. Many Agents. Zero Drift.
One agent is a tool. Many agents without shared identity is chaos. The multi-agent era needs a single source of truth about what the software is.
The Delta, Not the Document
Specs drift because they describe states. Deltas survive because they describe decisions. Stop writing better documents. Start declaring better deltas.
Adding to DNA Is a Decision. Adding to Code Is Just Typing.
When AI makes execution cheap, the scarce resource is not typing. It is deciding. The discipline of the next era is knowing the difference.
Beck, Karpathy, and Willison Are Saying the Same Thing
Beck, Karpathy, and Willison arrived at the same conclusion independently: AI agents need persistent, structured specifications. The vocabulary differs. The diagnosis doesn't.
Context Engineering Is Not Enough
Context changes per request. Identity persists across sessions, tools, and team members. Context engineering without identity engineering is a database query without a schema.
Platform Engineering Meets AI Agents: A Governance Framework
Platform teams are the natural governance layer for AI agents. Here's the framework for making it work.
MCP Security and the Missing Identity Layer
MCP has 97 million monthly SDK downloads and no built-in identity layer. That's a problem.
Non-Human Identity Management for AI Coding Agents
Your AI agents have credentials, make API calls, and access production data. They're operating on borrowed human identities with no scoped permissions. That's an identity crisis.
Stop Feeding Your AI the Whole Haystack
More context isn't the answer. The right context is. Your agent needs a schema to query, not a haystack to search.
Code Is Ephemeral. Identity Is Permanent.
Twitter rewrote Ruby to Scala. Uber's microservices have a 1.5-year half-life. The code is always temporary. The question is what persists.
The 3am Engineer Who Couldn't Find the Answer
Your best engineer quit. Your on-call just got paged. The service is down. Nobody who's awake has ever touched this code. This is the cost of undocumented identity.
Documentation Is Dead. Long Live Identity.
The $6 billion documentation industry is solving the wrong problem. You don't need better docs. You need software that knows what it is.
What Is Spec-Driven Development? The Definitive Guide
Spec-driven development is a paradigm where specifications are the primary artifact and AI agents generate code from them. Here's how it works, who's doing it, and where it's heading.
The Missing Layer Between Your AI Agent and Your Codebase
Every AI coding agent has context about your code. None have persistent understanding of what your software is supposed to be. That's the gap.
Software DNA: The Primitive Nobody Built
Software DNA is a declarative identity layer that defines what software is, what it should do, and what constraints it must honor. It's the primitive the industry has been building around without building.
Your Software Doesn't Know What It Is
Software runs the financial system, the power grid, the hospital. It has no persistent identity. In an era where 41% of code is AI-generated, that's existential.
Your Best Engineers Are Now Full-Time Reviewers. That's a Problem.
AI 10x'd code generation. Code review capacity didn't scale. Senior engineers are drowning.
The Invoice Your AI Agent Wrote While You Slept
96% of organizations report AI costs higher than expected. One agent loop cost $47K over 11 days. The FinOps problem nobody budgeted for.
The Hidden Cost of AI Agent Sprawl
Every team runs different agents with different configs. Nobody owns the governance. The hidden costs are compounding.
The Ghost in Your Engineering Org
Your most valuable asset walks out the door every evening. Some nights it doesn't come back. The cost of undocumented institutional knowledge is enormous -- and invisible.
Your AI Just Installed a Package That Doesn't Exist. Someone Else Made Sure It Does.
AI models hallucinate package names 20% of the time. Attackers register those names on npm and PyPI. The supply chain attack vector nobody saw coming.
Your AI Just Open-Sourced Your Proprietary Code. You Didn't Notice.
Two-thirds of commercial codebases have license conflicts -- an all-time high. AI strips license information during code generation. The legal exposure is real.
The $85 Billion Bug Nobody Files
The bug isn't in the code. It's in the gap between what is and what should be. And nobody's filing that ticket.
Your AI Wrote That Function Three Times. It Thinks They're All New.
AI-assisted coding is linked to 4x more code cloning. Refactoring collapsed from 25% to under 10%. Your codebase has three patterns for the same operation.
AI Is Training Your Junior Devs to Be Permanently Junior
Junior dev employment is down 20%. Anthropic's own study shows 17% lower comprehension with AI assistance. The skill pipeline is drying up.
You Ship Code You Don't Understand. That's Called Debt.
Werner Vogels coined verification debt. Addy Osmani coined comprehension debt. 96% of developers don't trust AI output, but only 48% verify it. That gap has a name now.
Your AI Has Root Access. Your Spec Doesn't.
Replit deleted a production database. Amazon's Kiro agent caused a 13-hour outage. Your AI agents have real permissions with no declared boundaries.
Vibe Coding Is Technical Debt on Autopilot
Collins Dictionary's Word of the Year. Y Combinator's favorite approach. And the fastest way to build software you can't maintain.