SDLC for my homelab is changing
Two articles landed in my queue the same week: Microsoft's New Agentic Software Delivery Primitives and Anthropic's Solving Code Review at Anthropic. Different companies, different scale, same underlying claim: the software delivery lifecycle hasn't changed shape, but where a human's attention goes inside it has moved almost entirely.
I read both back to back and realized I wasn't reading about the future. I was reading a description of my Tuesday night. I run a home lab on Paperclip, tl;dr: its an agent farm with project management built in, and it's completely open source. I'm the human in the loop, and I have no other humans on staff (the kids do share ideas tho), then it's just a roster of agents (with different skills and harnesses) that pick up issues, check them out, break down big tasks, write code, open PRs, and escalate when they're stuck. My actual role in this most evenings is not writing code. It's being the one human in the loop for an army of agents, in between whatever else I'm actually trying to get done. I've started calling those interruptions "sidequests," because that's what they are: small, bounded decisions that the fleet hands me, unrelated to whatever main quest I sat down to do. here is what my "hobby army" currently looks like:
The stages didn't change but now I get my hobby projects done! Honestly, a lot of my homelab sidequests sat in my TODO list for years, literally, but now I'm able to explore that, with the little time between dad time, work, and sleep.
Anyway, back to SDLC, Microsoft's framing is the clean version of this: Plan, Build, Verify, Observe stay as the durable shape of the SDLC. What changes is who does what inside each stage.
Planning - I still pick which problems are worth solving by creating tasks for my CEO agent (Benard, yes I name them) to create a new project, or organize the next phase of a new project. An agent can help me shape an issue into something actionable, but deciding that I want to create a new game that my daughter had an idea around takes precidence over my server maintenance is my call!
Build - this is almost entirely agents now. I write an idea file with a few bullets, an agent picks it up, drafts the whole thing, opens a PR. On complex things, I ask it for a plan, it uses Superpowers (a nice agent plugin workflow) and then shares a doc. Paperclip lets you mark up the plan with comments, and then i ask the agent to review. Building is breaking down, having the low-cost models do most of the implementation, with review from the CTO (Mat
Verify - agents do the first pass (does the draft hang together, does the code run, do the tests pass). My job is the second-order question: does this match what I actually meant.
Observe: I decide what merges, what gets published, what gets reverted. Agents can flag that something looks off; they can't decide it matters to me.
Microsoft calls the thing connecting all of this the "knowledge layer"; goals, decisions, context, evidence, history, all in one place so agents aren't re-deriving intent every time they wake up. In my setup that's just... the Paperclip issue. The description is the goal. The comment thread is the decision history. The chain of command is who to escalate to. When an agent wakes up on a heartbeat, it reads the issue, which only works because I've been disciplined about putting the "why" in the issue and not just the "what." This has mixed success rate, but you can really tell the difference in the output. A little planning up front goes a long way in the implementation.
Seven layers, scaled down to one guy and a laptop
Anthropic's post is the one that actually describes the mechanics I'm copying. Their situation is extreme, Claude writes most of Claude Code's own codebase, daily changes in the monorepo went from 2_500 to 30_000 (wow), and line-by-line human review of that volume is not just tedious, it's mathematically impossible. So they stopped asking "did a human read this?" and started asking "which check catches which class of problem?" Then they built seven of them in sequence: Claude reviewing its own PR, AI review with consensus voting, dedicated security review, CI, risk-scaled human approval (zero approvals for a docs fix, two people for something dangerous, in my case this is just me, nothing is too crazy), a merge queue, and fast rollback as the last safety net.
The part that stuck with me isn't the seven layers, it's the metric. They don't measure success by how many PRs got approved. They measure it by revert rate. If reverts go up, they didn't save time, they just moved the cost further downstream and made it more expensive.
Mapped onto my home lab, the layers look thin but they're the same shape:
The agent tests its own draft before opening a PR.
A review pass (sometimes me, sometimes /code-review) hunts for obvious problems.
CI-equivalent: does it build, does the markdown render, did it touch something it shouldn't.
Human approval: me, every time, because I don't have a "low risk, skip the human" tier yet. sidequest note: I'm experimenting on this with a new setup, you'll see Luna above for a racing card game I'm thinking about)
Merge.
Simplified for my environment, but still helps ensure quality (enough for homelab experiments).
What's actually left for the human: sidequests
Here's the honest inventory of what I spend time on, across a week of running this fleet:
Blocked escalations. An agent can't proceed, missing credential, ambiguous requirement, a decision above its pay grade.
PR review. Second layer PR review, did it do what i wanted to, i also typically do manually testing here too.
Chain-of-command pings. CEO gets an escalation which needs judgement it can't decide, I come in to help.
Approvals. Anything that needs a human sign-off before it ships, e.g. adding a new sub-agent with a different config.
None of these are the main quest (idea generation, but that is something I do as well). They're small, they arrive asynchronously, and the whole design of the heartbeat procedure: wake up, check assignments, checkout, do the work, comment, exit. This assumes a human is going to be periodically dropping in to clear exactly this kind of queue. That's the real product of both articles, stated plainly: human attention is the scarce resource, and the job is routing it to the handful of decisions that actually need it instead of spreading it thin across everything.
Where my setup is honestly behind
I don't want to oversell the home lab as a mini Anthropic. A few gaps are real:
No risk tiering. Everything gets the same level of human gate right now, but I'm exploring some auto-merge in my next project, update blog when that is complete.
No revert-rate tracking. I don't yet measure whether my approvals are actually catching anything, or whether I'm a rubber stamp with extra latency. I have observed a few main breaking issues I should have caught in testing, but overall by the time it gets to me, its usually solid.
I'm still the single point of failure, which is fine. Microsoft's model assumes the human in the loop is doing high-leverage judgment. Some weeks I'm just slow, and the whole fleet backs up behind me, which is its own argument for building the risk tiers sooner rather than later.
TLDR
Both posts are making the same bet: the SDLC's shape survives, agents absorb the stages that are mostly execution, and the human's job concentrates into judgment calls that arrive unpredictably and need to be handled well, not handled often. Running that at home-lab scale instead of monorepo scale doesn't change the lesson, it just makes the lesson legible, because I can watch every sidequest land in real time instead of inferring it from a revert-rate dashboard.
I have an idea. The agents plan and build. I do sidequests to get it across the finish line. So far, that's the whole job.
Comments
Post a Comment