Skip to main content

20 - Agentic Workflow with GSD: Who Decides, Who Executes

A booking module in about four hours with GSD and agents, as I tell it: who decided, who executed and why review stays human.

What do you think about this article?

20 - Agentic Workflow with GSD: Who Decides, Who Executes
Claude Code Workflowfedericocalo.dev

At a Glance

A booking module in about four hours with GSD and agents, as I tell it: who decided, who executed and why review stays human.

Direct answer

In my account, not measured with a stopwatch, a booking module that I would have estimated at one or two days became an afternoon of about four hours with the GSD agentic workflow: the agents wrote endpoints, tests and interface in parallel while I stayed the guide who decided the rules, the data and what went to production.

The agents did not replace me. They removed the parts where I was slowest. This is the uncomfortable claim that divides people: anyone who fears agentic coding pictures a developer being swapped out, while the reality of my monorepo is the opposite. The bottleneck was never writing boilerplate: it was the cost of context-switching between decision, writing, testing and review. The agentic workflow attacks exactly that cost.

Transparency note. Everything that follows is direct experience on my brownfield portfolio (3 microservices in production on a VPS). The coding agent is an accompaniment tool, not the protagonist: product decisions, real data and the final review stay mine. The AI provider of the portfolio's runtime services was, until 23 October 2026, Ollama on-prem installed on the VPS - a topic separate from the tool I write the code with.

Update of November 2026: from 23 October to 12 November 2026 the AI provider of the site's services was OpenRouter (free plan, zero cost). Every request carried the setting data_collection: "deny", so prompts were not used to train models; I cannot say, however, that they were not retained, and the service had no EU in-region routing, so data could leave the Union. Since the deploy of 12 November 2026 the site uses a local AI engine on its own server, in Europe, with a job queue: AI requests are not sent to third-party providers, and on a CPU without a GPU response times are longer. The phrases "no data leaves" and "on-prem" further down describe the Ollama period.

The numbers in this article, starting from "about four hours", are my account of one session and not a measurement you can repeat: I report them as a personal account and not as a benchmark. The claims about the tools, instead, have a source at the bottom.

The real problem is not typing speed

Anyone who measures productivity in lines written per minute is looking at the wrong metric. On a real codebase the time goes elsewhere: understanding where to put your hands, holding the context while you jump between three services, remembering the convention of that layer, and above all not breaking anything. Typing is the easy part, so optimizing it buys little.

GSD (Get Shit Done) is the phased planning system I use. The public repository describes it as a system of spec-driven development that takes coding agents through a cycle repeated for every phase: discuss the decisions before planning, plan and break down, execute the plans in parallel waves (each run by an agent with a clean context), verify, and finally deliver. The agent that executes a plan, according to its description, works with a commit for every task. This is the core of the method, and it is also why it holds up: every plan is small enough to fit in a fresh context, and every task leaves a trace in git that you can reread. On top there are agents specialized by stack (one for the Spring backend, one for Angular, one for review, one for security): they are mine, not GSD agents, and in GSD's public repository I did not find any for Spring or Angular.

The part a human alone cannot do is parallelization: plans with no dependencies between them, declared in the depends_on and files_modified fields of each plan, run in the same wave. How you check for a hidden dependency I show in the article on cascading debugging; here it is enough to say that it is the condition that decides whether parallelization works or produces conflicts.

The real case: a booking module in about four hours

I wanted a custom booking module instead of an external service: availability slots, a request with approval through a signed magic link, three transactional emails, an .ics attachment, plus two Angular surfaces (a gated page for the account and a public, indexable landing page). On paper it is one or two days of work. With the agentic workflow it became an afternoon.

It is not magic and it is not vibe-coding. It is a change of role: I stop being the person who writes every line and become the person who decides, steers and verifies. The value I bring is no longer syntax, it is judgment.

Who did what

  • Me (the guide): the domain rules (time windows Mon-Fri 8:00-8:30 and 18:30-19:30, Sat-Sun 8:00-19:30), the choice of request-then-approval instead of direct booking, the two addresses that approve, the token secret, and the final review on security and UX.
  • The agents (the accompaniment): the REST endpoints for availability and for creating a pending request, the approval flow with magic link, the generation of the emails and of the .ics, the two Angular pages with state and errors handled, and the first pass of tests.

The split follows a simple rule: to me the choices whose consequences are hard to undo (who can approve, how a token is signed, what gets published), to the agents the parts whose result I can verify by reading the diff and running the tests. It is not a split between "hard things" and "easy things": the endpoints are not trivial, but they are verifiable, while the choice between direct booking and a request with approval is not.

The data: where the four hours went

This is the breakdown of the session as I report it, separating the time of active human guidance from the working time of the agents. The two do not add up in wall-clock time: a lot of agent work runs while I read, decide or deal with something else, and that overlap is exactly what compresses the total. These are minutes declared by me, not recorded by a tool.

Time breakdown by phase between human guidance and agents in the build of the booking module
Phase Human guidance (min) Agents (min)
Discussion and domain decisions 40 0
Planning and decomposition into waves 15 25
Execution (backend, email, .ics, 2 UIs, tests) 20 110
Review, fix and merge 35 15
Total active 110 150
Session on my monorepo, minutes declared by the author. Clock time about 4 hours thanks to the overlap between guidance and agents; the active minutes must not be read as a sequential sum.

A table of declared numbers can at least be checked for consistency. The script below measures nothing: it recomputes the totals from the rows, counts the share of human guidance that went into discussion and review, and shows what the numbers imply about the overlap.

"""Arithmetic check of the article's timing table: the data are the ones declared by the author, not measured here."""

# (phase, minutes of human guidance, minutes of agent work), as declared in the account.
FASI = [
    ("Discussion and domain decisions", 40, 0),
    ("Planning and decomposition into waves", 15, 25),
    ("Execution (backend, email, .ics, 2 UIs, tests)", 20, 110),
    ("Review, fix and merge", 35, 15),
]
TOTALE_DICHIARATO = (110, 150)
WALL_CLOCK_MIN = 4 * 60  # "about four hours"

umano = sum(f[1] for f in FASI)
agenti = sum(f[2] for f in FASI)
print("computed totals:", umano, agenti, "| declared:", TOTALE_DICHIARATO, "| match:", (umano, agenti) == TOTALE_DICHIARATO)

giudizio = sum(f[1] for f in FASI if f[0] in ("Discussion and domain decisions", "Review, fix and merge"))
print(f"human guidance in discussion and review: {giudizio} of {umano} minutes = {giudizio / umano:.0%}")
print(f"agents' share of total active time: {agenti} of {umano + agenti} = {agenti / (umano + agenti):.0%}")
print(f"active time {umano + agenti} min against {WALL_CLOCK_MIN} min of wall clock: overlap of at least {umano + agenti - WALL_CLOCK_MIN} min")

# Output:
# computed totals: 110 150 | declared: (110, 150) | match: True
# human guidance in discussion and review: 75 of 110 minutes = 68%
# agents' share of total active time: 150 of 260 = 58%
# active time 260 min against 240 min of wall clock: overlap of at least 20 min

The four lines of output say this. The totals of the rows match the ones written in the table (110 and 150), so there are no addition errors. Human guidance in discussion and review is 75 minutes out of 110, that is 68%: it is an indication of how my time shifted, not a measurement. The agents account for 58% of the active time. Finally, 260 active minutes against about 240 of wall clock imply an overlap of at least 20 minutes, and that is all the declared numbers allow me to say: the compression is there, but the table is not enough to quantify it any better.

The number that matters is not "150 minutes of agents". It is that my active share shifted: more than two thirds of my time concentrated in discussing the rules and in review, that is where human judgment is worth the most. Pure writing, once dominant, has almost disappeared from my account.

Where agents waste your time

It would be dishonest to tell only the savings. Agentic coding has a real cost, and ignoring it leads to disappointment. Three points where I paid the toll in this and other sessions.

  1. Implicit conventions. An agent does not know my historical gotchas (for example: never edit a Flyway migration that has already been applied, or production crashes). If I do not put them in black and white in the project rules, it reinvents them. The time spent writing them down once pays off, but the first time is pure cost.
  2. Over-engineering by default. Left free, an agent adds abstractions I did not ask for. Review also serves to remove, not only to validate. On real codebases subtracting is more valuable than adding.
  3. The false safety of green tests. A passing test does not mean a test that checks the right thing. I learned to read the asserts, not only the green color. This check cannot be delegated.

The three points have the same root: the agent does exactly what the context allows it to do, and you write the context. Implicit rules become errors because they are not in the context, the superfluous abstraction is born where nobody set a limit, the useless test passes because nobody said what it must verify. That is why the first item has the highest return, and why the project's rules file counts as much as the code: Claude Code treats it as context and not as imposed configuration, as I explain in the article on memory, and what must be enforced goes into hooks.

The rule I drew from it: agents speed up what I already know how to evaluate, and slow down what I do not yet know how to evaluate. Specifically, if I could not judge the output on my own, the agent amplifies the risk instead of reducing it.

The role of AI: accompaniment, never director

Here is the positioning point I hold firm. AI is the crew, not the director. In my flow a human always decides: what to build, under which constraints, what is acceptable to put in production. The tool quickly executes the mechanical parts, but responsibility for the result stays with the person who signs the commit.

I apply the same discipline to the product. The portfolio's AI services ran on Ollama on-prem on the VPS (until 23 October 2026: no data left the server), then on OpenRouter, free plan, until 12 November 2026, with controlled degradation if the provider was down or limited requests; today they run on a local AI engine on the site's server, with a job queue (see the update note at the top). The tool I write code with is one thing; the provider that serves users is another.

How to adopt this workflow (you, not me)

If you write software and want to try this way of working, the value is not in copying my agents: it is in changing your role. Start here, in order of return.

  1. Write your rules. A project conventions file (stack, gotchas, what is forbidden) is what makes an agent useful instead of dangerous. It is the investment with the highest return.
  2. Separate decision from execution. First decide the rules and the boundaries, then let it execute. Do not mix the two moments: that is where context is lost.
  3. Make review non-negotiable. Read the diff, read the asserts of the tests, ask what is missing. Speed upstream is worth it only if the gate downstream is serious.
  4. Parallelize only what is independent. Two tasks that do not touch each other can run together; two that share the same file cannot. Knowing how to tell them apart is an architecture skill, not a prompt skill.

The order is the order of return on investment, and it is not interchangeable: without written rules the separation between decision and execution has nothing to pass on, without a serious review speed only produces errors faster, and parallelization, which is the last step, multiplies both the results and the defects. Anyone who starts from the last point, because it is the one that makes the news, gets the opposite of what they are looking for.

What I learned writing this piece

The biggest surprise was realizing how little of my value was in typing. For years I measured my day in code produced; today I measure it in decisions made well and problems not created. In fact the agentic workflow did not make me less of a developer: it forced me to be clearer about what I want, because now someone executes literally what I write.

This is the last article of a series that starts from a practical guide and that I closed with the integration between skill, agent and plan: it is the account of a real piece of work, while the others are the pieces it is made of.


Related cluster: the debugging skill Need a custom module like this? Let's talk

Frequently asked questions

Does agentic coding replace the developer?

No. In my flow it shifts the value from writing code to deciding, steering and verifying. The agent quickly executes the mechanical parts, but the domain rules, the real data and the final review remain a human responsibility. Anyone who cannot evaluate the output should not delegate it.

How do you build a module in about four hours?

In my account, not measured: I do not optimize typing speed but context-switching. GSD splits the work into phases and atomic tasks, the specialized agents execute the independent plans in parallel while I decide and verify, and the overlap between human guidance and agent work compresses the clock.

What are the downsides of the agentic workflow?

Agents reinvent unwritten conventions, tend to over-engineer, and produce green tests that do not always check the right thing. They speed up what you already know how to evaluate and amplify the risk on what you cannot yet judge. Review remains non-delegable.

Which AI provider does the portfolio use?

From 23 October to 12 November 2026 the portfolio's runtime AI services ran on OpenRouter (free plan, zero cost), with data_collection: "deny" on every request: prompts were not used to train models, but data could leave the Union and I did not claim they were not retained. Until 22 October 2026 they ran on Ollama on-prem on the VPS. Since the deploy of 12 November 2026 the AI services use a local AI engine on the site's server, in Europe, with a job queue: AI requests are not sent to third-party providers, and on a CPU without a GPU response times are longer. The tool I write code with is a distinct thing from the provider that serves end users.

Sources

  • open-gsd/gsd-core, README - the cycle of discuss, plan, execute in parallel waves with a clean context, verify, deliver. Accessed on 2026-11-13.
  • open-gsd/gsd-core, gsd-executor agent - execution of plans with a commit for every task. Accessed on 2026-11-13.
  • Exploring Generative AI - Martin Fowler - a collection of Thoughtworks notes on development practices with AI, including agentic engineering experiments; read as context, no figure is taken from it. Accessed on 2026-11-13.
  • How Claude remembers your project - CLAUDE.md files as context and not as imposed configuration; to block an action you point to a PreToolUse hook. Accessed on 2026-11-13.
  • Ollama - the project's site, cited for the passage on the provider of the portfolio's services. Accessed on 2026-11-13.

Try These Tools

Free developer tools related to this topic.

Commenti

Caricamento commenti...

Sign in to comment

New articles and tools on Telegram too

The Telegram channel flags the site's new articles and tools.

Did you like this article?

Explore other content on the blog or discover my projects