# Agentic SDLC, Part 1: How Will You Prove It Works?

**Summary:** Lessons from claude-codex, VCP, and GitVibe: define success, test complete user journeys, and turn verified failures into regression checks and a maintenance feedback loop.

- Canonical: https://markhuang.ai/blog/agentic-sdlc-part-1
- Language: en
- Author: [Mark Huang](https://markhuang.ai/about)
- Published: 2026-11-16
- Section: Tutorials
- Tags: agentic-sdlc, ai-agents, software-testing, e2e-testing, maintenance
- License: https://creativecommons.org/licenses/by-nc/4.0/

---

![An illustrated application with its front panel lifted away, exposing a disconnected internal path beneath an inspection lens](https://cdn.markhuang.ai/blog/agentic-sdlc-part-1/hero.webp)

*A finished-looking product can still hide a broken journey. Conceptual illustration.*

I have worked on 3 projects aimed at bringing more of software development into an agentic workflow: [claude-codex](https://github.com/Z-M-Huang/claude-codex), [VCP](https://github.com/Z-M-Huang/vcp), and [GitVibe](https://github.com/markhuangai/git-vibe). The ambition is straightforward: let AI do work I would be comfortable accepting from a group of senior developers, and end up with a product someone can actually use. That someone might be me. It might be the public.

Getting there is really hard. I do not think it is entirely impossible, but I would be careful about calling any of those attempts proof that I have solved it. What I can share is how they changed the questions I ask before starting.

I now start by defining success, deciding how to test it, and planning how to keep it working. Testing is the part I worry about most. AI can produce a convincing implementation while leaving me with very little evidence that the product does what its user needs.

**SDLC means Software Development Life Cycle.** It covers the work of planning a product, understanding requirements, designing it, implementing it, testing it, deploying it, and maintaining it. Teams organize these activities differently, and often repeat them rather than moving through them once. [IBM's SDLC explanation](https://www.ibm.com/think/topics/sdlc) provides a useful introduction.

By a *full agentic SDLC*, I mean involving AI agents across that lifecycle, including the work after the first implementation. The word “full” describes the ambition. It does not mean removing the person responsible for deciding what the product should do or accepting the consequences when it fails. GitVibe, for example, documents a workflow that deliberately keeps maintainers in control of implementation, review, and release decisions.

These are the three questions I would answer, in this order:

1. What does success look like?
2. How are you going to test it?
3. How are you going to continuously maintain it?

I intentionally left out “How are you going to build it?” If you are reading this to build an agentic solution, you have probably already chosen AI to do much of the building. You still need to make architecture and implementation decisions. Choosing AI does not make those decisions disappear; it makes it easier to start implementing before you have answered the other questions.

## 1. What does success look like?

Without a goal, there is always another feature to add. A dashboard would be nice. Perhaps notifications too. Then a plugin system, because someone might need one later. Eventually you have a Frankenstein repository, and the AI starts criticizing the architecture it helped generate.

I described an earlier version of this problem in [Automation Without Intention Is Just Faster Chaos](/blog/automation-without-intention-is-just-faster-chaos). My pipeline could produce features, but maintaining the pipeline itself consumed too much of my attention. Simplifying it then cost me visibility into what it was doing. Those experiences made “what am I trying to finish?” a much more practical question.

Start with one consumer and one useful outcome. If the consumer is you, say what you want to accomplish with the product. If it is someone else, describe their task in words they would recognize. Then write down what would convince you that this first version is done, along with what you are deliberately leaving for later.

For a small, hypothetical example, imagine an app for keeping items you want to revisit. The first useful outcome could be: **I can create an item, save it, reload the page, and find that same item again.** This is an illustrative requirement, not a report of a particular failure in my projects.

That sentence leaves room for design decisions, but it gives the work a boundary. Accounts, collaboration, and recommendations can wait. A page with a working Save button and no way to recover the item after reload has not met this goal, however polished it looks.

Keep the acceptance criteria outside the implementation so they remain available when you review the result. Otherwise, it is too easy to let whatever the AI happened to build become your new definition of success.

## 2. How are you going to test it?

If you are building alone, you may have no dedicated QA team waiting to exercise every release. You have to decide how you will find problems. Leaving that question until the product looks finished makes the answer much harder.

Unit tests help a lot. They give an agent quick feedback while it is changing code and help it locate what it broke. But I have already written about seeing unit tests pass while the user flow was still broken. That was why I added user acceptance testing, or UAT, to my earlier pipeline: I wanted to check the scenarios I had actually asked the product to support.

The small item-saving example makes the distinction concrete:

| Check             | What it can establish in this example                                                      | What it leaves open                                                                 |
| ----------------- | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------- |
| Unit test         | The item-validation or serialization function handles the tested inputs correctly.         | Whether the UI calls the right code and the item survives a reload.                 |
| Integration test  | The save and load paths work with the actual storage component in the test environment.    | Whether the complete user journey reaches those paths correctly.                    |
| End-to-end test   | A user can create, save, reload, and retrieve an item through the tested application.      | Other journeys, untested environments, and whether people understand the interface. |
| Agent exploration | An agent can attempt the task and produce evidence of obstacles or failures it encounters. | Whether its judgments and behavior represent human users.                           |

**End-to-end testing, usually shortened to E2E, is extremely important to me.** It exercises a complete journey across the application. For this example, the assertion should check that the same saved content is available after reload. Checking only that a success message appeared would leave the useful outcome untested.

Use a test environment that resembles the deployed product where the journey depends on it. Exercise real persistence for a persistence requirement. Include relevant failure cases, such as a save request failing, rather than letting a mocked success response stand in for the behavior you need.

I would rather over-test than under-test. More meaningful scenarios give me more confidence. Still, ten copies of the same happy path add little, and a flaky suite that everyone learns to ignore can make release gates ineffective. [The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html), by Ham Vocke, explains why broader tests generally bring more execution and maintenance cost. I want coverage of the behavior that matters, not a larger number to celebrate.

A passing E2E suite tells you that the journeys it exercised worked under its test conditions. Production may differ in configuration, data, permissions, or external services. Tests help close that gap; they cannot certify every production outcome.

### Let an agent try to use what you built

After the repeatable checks, I want another kind of feedback: give an agent a task and let it operate the product. The tool depends on what you built. A web app needs an agent that can interact with its interface; a command-line tool needs one that can run the documented commands. Looking at screenshots or reading the source alone does not exercise the same journey.

The distinction is between setting the rules of the test and teaching the agent how to succeed. Give it the environment, a task, and reporting requirements. Let it discover the steps using the help an ordinary user would have. For the hypothetical app, I might use this prompt:

```text
Use the designated staging app and disposable test account.
Task: Keep an item you want to revisit, then return to it after reloading.
Work through the public interface and its user-facing help.
Do not read source code, modify the app, or use private APIs to finish the task.
Stay within this account. Stop after 10 minutes or if progress is blocked.
Record what you tried, what you expected, what happened, and any confusion.
For a suspected failure, save the steps and screenshots or logs needed to reproduce it.
Report whether you completed the task. Do not invent evidence.
```

This is an exploration prompt, not a claim that I have run this exact experiment. A scripted E2E check already knows a route through the product. Exploration can uncover a missing route, an unclear label, or a case I did not think to script.

I would put repeatable E2E scenarios in place before spending repeated agent runs rediscovering known failures. Exploration has variable execution and review costs; the cost comparison depends on the product and the tools. It is another way to look for gaps, rather than a reason to discard the cheaper checks that already work.

Keep its findings honest. A screenshot showing that an item vanished is evidence worth investigating. An agent saying “users will find this frustrating” is a hypothesis. Research such as [UXAgent](https://arxiv.org/abs/2504.09407) explores simulated interaction as support for preparing usability studies, while [Nielsen Norman Group's review of synthetic users](https://www.nngroup.com/articles/synthetic-users/) explains the limits of treating generated responses as human research. Get feedback from actual people as soon as you can.

When exploration finds a reproducible bug, turn it into a lasting regression check. The next release should not need another expensive discovery to catch the same mistake.

> “You will not get there in the first attempt. You will make mistakes, and mistakes will make you better.”
>
> Mark Huang

I want the mistake recorded clearly enough that the next attempt can improve on it. Diagnose the failed journey and keep a regression test that catches it.

## 3. How are you going to continuously maintain it?

The first usable version still needs updates and fixes. Early on, there may be nobody sending bug reports. You need ways to notice problems before a growing user base supplies that feedback for you.

Release gates are one part of that. Unit tests and E2E tests are strong candidates: do not release a change while a required check is failing. Analyze the failure. If the implementation broke the intended behavior, fix it. If you intentionally changed that behavior, explain the new requirement and update the test accordingly. Changing an assertion simply because the generated code disagrees with it would let the implementation grade itself.

The gate should run the actual checks and retain their results. An agent saying “all tests passed” is not a substitute for the test runner's output. My earlier pipeline also used iteration limits and escalation when it could not resolve failures. An endless fix-and-retry loop can consume resources without producing a better product.

Then give the product a feedback loop. Depending on the product, that might combine scheduled checks of important journeys, errors from the deployed application, agent exploration, and user reports. Each finding needs enough context to investigate. Verify what happened, decide whether it is a defect or a request, and route it into the work that follows.

```mermaid
flowchart TD
    accTitle: From a verified failure to the next release
    accDescr: Observe and verify a problem, diagnose and fix it, retain a justified regression check, and release only after required checks pass. Failed checks return to diagnosis. Released changes return to observation.
    A["Observe a problem"] --> B["Verify and record an issue"]
    B --> C["Diagnose and make a fix"]
    C --> D["Add or update a justified regression test"]
    D --> E{"Required release checks pass?"}
    E -->|"No"| C
    E -->|"Yes"| F["Release and observe again"]
    F --> A
```

*Verified failures feed the next change and its regression checks. Failed gates return to diagnosis; they do not become permission to ship.*

AI feedback can become a new issue or a proposed fix. Both still need evidence and review. Keep someone responsible for accepting changes and deciding when to release them. Automating more of the work does not remove the need for that decision.

This is where I would start Part 1: choose a useful outcome, write down how you will prove it, and decide how a future failure will reach you. Before adding the next feature, try the complete journey you already promised. Can the consumer finish it, and will you notice when they cannot?
