The SDLC Was Designed for Humans | Yusuf Aytas

I was doing research on what to build next in the AI world. I’ve done a few hobby projects that have gone nowhere. I was fishing for the next. I was looking for an interesting idea to implement. So, I decided to take a look at recent job descriptions to see what companies want and where they want to go.

To my surprise, companies in very different domains look like they are asking for similar capabilities. Initially, most of the conversation around AI driven development was about producing and understanding code. Now, the problems are gradually moving to agentic development. Job descriptions talk about skills and MCP, standardized environments, reusable patterns, service metadata and permissions. Then there is evaluation, traceability, audit and the cost of work done by LLMs. These are different industries, different names, but they appear to be converging on the same question. How do we get LLMs to do repeatable, trustworthy and usable work?

We’re well past the stage where LLMs were autocomplete. We’ve been putting them deeper and deeper into the SDLC. The bizarre thing is that producing software is starting to move beyond human speed, while the rest of the system still assumes a human is on the other side.

Where Human Approval

We Put AI Into the Old Machine

When we first interacted with LLMs, we put them into our existing human workflows. That was rather a practical approach. Now, with the advent of agentic workflows, they are expected to be side by side with humans. The trouble is that almost everything around software development was designed around humans. Our throughput, permissions, development environments, review systems and ownership models all fundamentally assume that the actor doing the work is a person.

Our existing system looked roughly as follows.

Classic SDLC

Agents are different, for one, there can be many, and they do not necessarily operate at human speed. One engineer can have several agents making changes at once. That changes the assumptions underneath our entire development pipeline.

A pull request assumes changes arrive slowly enough for another human to inspect them. CI capacity roughly follows the pace at which humans produce code. Service ownership assumes teams create software slowly enough to absorb it. Permissions assume the actor exercising them is a person who can be held accountable later. All of that starts to break when the worker is an agent, because our system was never designed for something that can produce this much shit this quickly.

Humans Have Been Filling the Gaps

Today, humans are filling the gaps. For instance, we have been writing our documentation in markdown files, even more, we have been even writing ticket description, designs in such a way. That helps give context for AI because it can then pattern search what happened.

We have also been building paved paths for years to repeat quality across repositories. The difference is that another consumer has arrived. Now, we need to do the same for LLMs but the trick is to get them to consume it. Companies are investing in reusable patterns, reference architectures, service metadata, machine-readable instructions, skills, templates, development environments and explicit context delivery. Hence, standardization and paved paths appear again and again.

A surprising amount of what we will call LLM-ready platform engineering is really the work of converting organizational knowledge into something a machine can consume. Things engineers used to learn from another engineer, infer from a repository, or discover by asking around now have to become explicit. We have wanted better documentation for years and there is never enough of it. Apparently agents are finally going to make us write the damn thing, pro bono.

The Developer Platform Gets a New Persona

If you think about modern platform engineering, we standardized a few good things. With the new persona coming in, we need to think a bunch of these capabilities in terms of agents. Standard questions like how do I deploy, how do I create a ticket, where are my logs, how do I get credentials, who owns this service and so forth need to be calibrated against both humans and agents.

Developer experience, AI platform, security and developer productivity are already bleeding into each other. I don’t think the names will matter for long. Call it whatever you want. We are going to end up with a platform that has to work for both humans and agents.

Once an agent needs to discover a service, figure out who owns it, get credentials, make a change and prove what it did, our concerns start collapsing into each other. Humans have been filling the gaps with judgment, memory, reputation and the ability to ask someone what the hell is going on. Agents need those things represented in the system.

Limits will be Part of Control Plane

Now, we are solving the problem of what LLMs are allowed to do and what they aren’t. If you...