Agentic SDLC is software delivery where agents participate across planning, coding, review, test, deployment, monitoring, and recovery. The important part is not “AI writes code.” The important part is that the whole development loop changes.
For me, the shift happened in stages.
At first, I used agents like a faster editor. Give one agent one task, get one diff back, clean it up myself. That was useful, but it was not transformational. The bottleneck moved from typing code to shaping tasks, catching bad assumptions, keeping context alive, and reviewing the flood of PRs.
The second phase was role separation. An architect clarifies the goal and decomposes the work. A coder owns a bounded change. A reviewer looks for regressions, missing tests, behavioral drift, and risky abstractions. A babysitter watches CI, requests review, summarizes failures, applies narrow fixes, and keeps the PR from going stale. OpenClaw became the place where those roles, skills, memory files, crons, approvals, and work queues could live as an operating system instead of as a pile of prompts.
The third phase is where I am now: agent operator. I still set direction and make judgment calls, but I am no longer trying to personally type every line. I am designing the system that lets agents produce steady, reviewable, reversible progress.
The chart is intentionally imperfect evidence. GitHub can expose private/restricted aggregate contribution counts to the authenticated viewer without exposing private repository names. Public commit counts are only part of the surface. But the shape is still useful: older work is mostly j1z0; then agent assisted work starts to dominate; then the happyclaw-agent account appears as a dedicated agent operator identity. By March 2026, I treat essentially all of my own coding work as agentic too, even when the commits still land under my account.
The operating model
Human sets goal, risk level, and success signal.
Agent decomposes work into reviewable slices.
Coder agent edits within a bounded ownership area.
Tests, screenshots, smoke checks, and diffs explain what changed.
Reviewer agents and humans route PRs by risk.
Crons, monitors, rollback, and memory keep the loop moving.
The useful thing OpenClaw gave me was not one magic agent. It was a workspace model.
Shared reusable behavior belongs in skills. Product code belongs in repos. Per-agent state belongs in workspaces: todo.md, current_task.md, daily memory, lessons, regressions, and operating notes. That sounds boring until the agent has been running for weeks. Then it is the difference between a coherent system and a fresh amnesiac session every morning.
In the Swoleby work, this became very concrete. A Discord accountability bot needed preflight checks, attempt logging, retry artifacts, and a reliable way to prove that a failed send had been retried. A content engine needed hooks, platform outputs, media generation, approval batches, briefing links, and eventually an apply worker that can schedule approved content and regenerate rejected items. The agent loop stopped being “write some code” and became “operate this production-ish workflow without losing state.”
That is also where the regression files became important. The local OpenClaw notes include rules like: do not commit secrets, route all social content through approval before publishing, log every post, avoid duplicate content, keep captions from shipping escaped newline characters, verify auth before reporting empty research, and keep todo files parseable so automation does not drop tasks. These are not inspirational principles. They are scars turned into guardrails.
Agents need guardrails made of systems
The more agents can do, the less useful it is to “review every line” as the main safety strategy. You still review important code. But if the system depends on a human reading every token of every agent-authored diff, the system will not scale.
The better pattern is layered safety:
Feature flags and entitlements keep risky capabilities off by default and reversible fast.
Short deploy gates prove the server, feature contract, and core tools are alive.
Full test suites run on schedule; agents classify flaky, infra, and real regression failures.
One command rolls back, waits for rollout, runs smoke tests, and reports pass/fail.
Each feature gets a small on-call reference: flags, APIs, health signals, failure modes, recovery.
Production heartbeat tests catch drift between deploys.
That guardrail stack came out of real enterprise agent-platform work. A large sandbox/code-execution feature had multiple independent capability slices moving in parallel. The only way to make that shippable was to surround it with feature flags, smoke tests, nightly regression triage, rollback, synthetic monitoring, and feature-level on-call manifests. The key idea is simple: do not ask humans to be the only backstop against machine-speed change.
The same principle applies to my personal agentic SDLC. I use review agents, babysitting skills, CI, browser QA, screenshots, smoke tests, regression notes, and cron-driven reminders because agents are powerful enough to make mistakes quickly. The protection has to be faster than the failure mode.
What is working now
Small PRs work. Large undifferentiated PRs are where agentic development starts to look like a mess. The system gets much better when every PR has a narrow purpose, a clear owner, and evidence attached to it.
Risk routing works. Copy changes, simple UI fixes, and documentation can move with lighter review when the smoke tests are strong. Auth, payments, data access, sandbox execution, user-visible behavior, and irreversible operations need stricter gates.
PR babysitting works. A loop that pushes the branch, opens the PR, waits for checks, requests review, summarizes failures, applies narrow fixes, and merges only when ready is much more valuable than a one-shot code generator.
Memory works when it is structured. Daily notes, todo.md, lessons, regressions, and project state let agents resume work without forcing the human to replay every decision.
Crons work when they produce reviewable artifacts. The Swoleby content engine is a good example: daily hook generation, batch building, approval packaging, morning briefing injection, and an apply worker are all separate pieces. The whole loop becomes inspectable.
Visual evidence works. Screenshots, charts, short recordings, and QA notes make review faster because the reviewer can understand user-visible behavior without reverse-engineering the diff.
What still needs work
The next frontier is trust calibration. Some low-risk PRs should eventually merge without me. Some medium-risk PRs should arrive with a strong enough explanation that review takes minutes. Some high-risk PRs should stop themselves before review and ask for a design decision.
That requires more than better models. It requires policy, ownership, test depth, rollback paths, feature flags, evals, and a history of previous mistakes that the system can actually read.
Agentic SDLC is not about removing engineering judgment. It is about moving judgment to the places where it matters most.
The human should not be the typist.
The human should be the operator of a system that can plan, build, test, explain, recover, and improve.
Related: Agentic SDLC skill, Agent-driven development needs a control plane, Sandboxing is a product feature, Agent evals should measure behavior, not vibes, OpenClaw and agent tooling, and Swoleby.