Frank Robert Anderson

org

Solving the problem: one engineer can work on a codebase at once

One engineer per project was the ceiling. Using tooling and process to clear bottlenecks.

1 → 12 engineers per release

Situation

One project, one engineer. Having two people work together required a great deal of coordination and communication.

Decision

Switch to git and adopt GitLab. Start using a development workflow with merge requests and timed releases. We ignore vanilla scrum and gitflow in favor of semantic git.

Result

Two engineers on a release used to be a struggle; five became routine, and over twelve during crunch periods. Any project could take any number of engineers at any time, and a release no longer waited for the one person with the expertise to be free.

Show the tradeoff Loading…

scaling

Serving 20 million objects for nearly nothing

Using AWS serverless to build a COPPA-compliant save-and-share feature that has run for ten years.

20M objects · 10 years · 100% uptime

Situation

Our client wanted a way to save and share the current state of the application.

Decision

I chose AWS serverless for the application and S3 for storage, deployed through AWS SAM, which was new at the time.

Result

Prototyped in 2016, launched in 2017, and still running mostly the code I wrote then. Seven contributors across five releases, most of them maintenance or language-compatibility updates. Ten years at 100% uptime. The monthly bill is S3 storage and bandwidth on more than 20 million objects and roughly a terabyte. For a well-architected system at a certain scale, serverless is unbelievable.

Show the tradeoff Loading…

strategy

The process I rewrote before it became the bottleneck

A release process built to let a dozen engineers share one codebase was the wrong shape now that writing code is no longer the hard part.

Situation

The department ran on a release process I had written years earlier, and it worked: merge request per feature, review and sign-off before merge, releases cut on a timed cadence. Management asked me to find out what GenAI did to that, and by the end of 2025 the answer was that we had made the first weeks of a project faster and the engineering needed clearer requirements before serious work could start.

Decision

Split the lifecycle into three funded phases instead of tuning the gate. Discovery produces a functional prototype fast, with engineering consulted rather than staffed, and its only job is a working baseline the client can argue with. Engineering then takes that baseline under Mark Cerny's pre-production method and develops it into a finished demo, which is the artifact the estimate gets written against: a date the client signs against and a token budget the shop holds itself to, both measured on a real build rather than guessed. The final build is scoped for maintainability and the decade after launch, because by then the features are already settled. The rejected alternative was to keep the existing process and simply run it faster, which fails because the cost was structural rather than a matter of pace; the other rejected alternative, shipping the prototype as the product, is the race to the bottom, since a prototype that survives contact with a client is not maintainable by default and pretending otherwise moves the bill to the next cycle.

Result

Three phases, two of them funded and delivered before a line of production code is written, and an estimate that arrives as a date the client signs against and a token budget the shop holds itself to, rather than a range. The number the method has to answer for is the gap between the demo's measured burn rate and the final build's, because that gap is the whole bet.

Show the tradeoff Loading…

tooling

The five-hour window, and the report nobody was there to start

A scheduling daemon for headless Claude Code sessions, managed through MCP because the users were not engineers and I was not building a GUI.

12 MCP tools · 0 lines of UI

Situation

Engineers on Claude Code subscriptions were losing capacity to the clock. The usage window is five hours long and it starts on your first prompt of the day, so a team that all sits down at nine is all locked out at two, in the middle of the afternoon.

Decision

I wrote blanket: a Go daemon that schedules Claude Code sessions on cron expressions and one-off delays. It drives Claude over the Agent Client Protocol rather than shelling out to `claude -p`, so the daemon itself answers the permission requests, and it exposes its whole management surface as an MCP server rather than a web UI.

Result

Sessions fire at six in the morning. The window opens before anyone sits down and closes at eleven, and the morning report is finished and waiting instead of being something you start and then watch. Twelve MCP tools cover the entire CLI surface, and the GUI on the todo list never had to be written.

Show the tradeoff Loading…