AI Writes the Code, but a Human Still Has to Run the Project? No.

AI Writes the Code, but a Human Still Has to Run the Project? No.

I read this take ten times a week: sure, AI writes code — fine. But to run a project, you need a human. Talk to stakeholders, write the plan, set up infrastructure, git, servers, monitoring. A machine cannot do that. And my eyes roll out of my head every time. I have walked the entire SDLC end to end with agents, pinning every step to a concrete tool and a production case. The cycle closes. No human is required in the loop.

Where you claim a human is needed — and what that costs

Faith in the irreplaceable human on the management loop costs money. While you keep a live analyst spending weeks reconciling the messy wish-lists of five stakeholders into one document; while a team lead manually slices an epic into tickets; while an engineer sits reading walls of logs hunting for an anomaly — you are paying for work an agent does in hours, including overnight.

And you are falling behind. While one team spends a month aligning requirements, another ships the feature. The difference is not intelligence. The difference is who still keeps a human where an agent has been enough for a while.

Requirements: the agent will not let an immature task into development

Writing a conversational bot-agent that discusses a project with stakeholders over chat or email is something any high-schooler could build. A voice mode — where the bot initiates a Zoom or Google Meet call and runs the conversation out loud — is slightly harder, but there are no technical blockers.

The agent reads the chaotic wish-lists, forms a single consistent picture, asks questions, and clarifies details. Dump the random desires of three to five stakeholders into a folder and run a prompt: reconcile this into a unified picture, detect contradictions, compile a list of questions, group them, and format as emails to specific recipients. This is elementary.

The cycle continues: new data arrives, you feed it to the agent, it welds the data into the documentation or asks a new question. When zero questions remain, you go to the next step. The agent then whips up an HTML prototype, shows it to each stakeholder, and asks: is this what you wanted? Really? Click through it and let me watch. A couple days of automated correspondence yields strict, consistent functional requirements, non-functional requirements, priorities, and goals.

I built a clarify-gate directly in Jira: the agent runs a structured dialogue across axes — scope, actors, data, NFRs, dependencies, acceptance criteria — and refuses to let a task into development until the spec is mature. With project context, the questions are grounded, not generic. The output is a grown-up ticket with verifiable acceptance criteria, not build an ERP integration. The code is open: a FastAPI service, Docker, webhook contract.

Design: two agents negotiate the contract themselves

Design and agreement are supposedly sacred human territory. Take two AI agents, one from each side of an integration, and let them conduct the negotiation and agree on a contract themselves. The output is an artifact: an openspec.yaml spec, a transcript of the negotiation, and a git history of the contract forming step by step. The principle is simple: an organizational boundary is crossed only by a contract (POST /orders), never by internal guts. Who owns what is wired straight into the endpoint. Transport across org boundaries is agent-to-agent over Git, with a shared repo as the live channel.

If you fear the agent cannot do architecture — make it read a book. RAG over Tanenbaum plus a wiki graph, so decisions rest on canon, not on the model's memory.

Planning and infrastructure: what is hard here?

Decomposition into a work plan? Anyone who has watched agents build plans has seen this. If plan mode in your editor is not enough, look at how GitHub SpecKit or BMAD work. The agent writes a decomposition for itself.

I run this through Spec-Driven Development: specify → clarify → plan → tasks → implement. The spec is the source of truth; code is the derivative. The agent does not invent the structure from scratch on every request — it inherits templates from the fixed memory of the project. This cures the exact anti-pattern everyone gets burned on: one prompt, the agent writes code immediately, an hour later the structure is incomprehensible, rollback is expensive, and the retro complains that AI cannot handle architecture. The problem was no spec. A separate planning tool uses git log as a dataset: churn, co-change matrix, pivotal commits, plus LLM interpretation on top.

Setting up infrastructure, git, Linux, CI/CD? I do not know what is complicated here. GitHub SpecKit writes this into tasks and lays out all NFRs from load to security. If you cannot picture a basic prompt like set up a server, prepare a docker-compose YAML for this project, and install Zabbix with these templates, I do not know what you are doing with AI.

Code: team practice, not a solo stunt

Coding is already baseline for many; there is nothing to argue about. But I will add proof that this is not one vibe-coder having fun. In an enterprise context, I built real production microservices through AI-assisted coding during regular team training: a next-best-offer ML model predicting the next item in a cart and in emails, an event-timestamp tracker across an order lifecycle, and a proxy microservice for geo-resolving coordinates to addresses. This is production, not a demo.

Two layers keep the agent from spinning in circles. First, reproducibility: the agent produces persistent, versioned artifacts, not ephemeral answers; a repeated task reuses a proven workflow instead of regenerating it. Second, agent memory: errors are logged into a structure the agent learns from, so it stops hitting the same rake.

Tests, demo, and release: eval as a gate

Test plans, test cases, and the automated tests themselves are also the agent. But here, against myself: an AI feature that runs beautifully on a demo breaks unpredictably in production because you tested the same inputs you pitched, and nobody ran the long tail of real traffic. So I set tests as a release gate with three layers: regression on cases from real incidents (a new failure blocks the release), a distribution check on fresh live inputs with a diff against the previous snapshot, and a human spot-check before the first production deploy of a new output type. One person signs off; if you cannot name that owner, that is the first red flag.

Preparing a demo for the client? No problem: the agent writes the docs, builds the presentation, opens a browser, and clicks through everything while recording a training video. At the release boundary, I keep guardrails: prompt-injection checks, data isolation, human-in-the-loop checkpoints. Review is a gate that catches real defects, not theater that imitates control.

Operations: logs, alerts, and user complaints

What is left? Monitoring logs and Zabbix alerts, fixing bugs on the fly, parsing live user emails with complaints and wishes, and dropping them into the backlog — at the start of this whole process. An agent for this is something anyone could build.

In operations, AI is a consumer of the event stream: Kafka, webhooks, monitoring. Parsing walls of logs, highlighting anomalies, automatic root-cause. This is production-grade engineering practice, not an experiment. I launched an AI bot against a data lake: a business question in natural language becomes SQL (read-only, with table-name validation), and time-to-insight dropped from days in a Jira queue to seconds.

The catch

Yes, things can go wrong; some places still need hands or a live head. I agree. But the entire SDLC maps onto agents right now. You can nitpick information security or the reliability of automated tests, but let us be honest: that is wasted effort. The core thesis does not change.

The cycle is closed

Feed this thing a steady stream of market hypotheses on the input, and it stamps out features on a conveyor belt. I have done exactly that. The next time you post a req for a delivery manager because someone has to run the project, read that job description back to yourself slowly — every bullet on it is a prompt you have not written yet.