Skip to content
Akram Moussaoui
CV PDF

Method

How I work with coding agents, what I hand over to them and what I keep. Two practices, written guardrails, and a human sign-off before anything ships.

Two distinct practices

I do not use agents the same way at work and on my side projects. At work, I stay hands-on at every step of the ticket. On my side projects, I hand the execution over to a chain of agents and keep the decisions.

At work: a ticket, a plan, tests first

At Groupe La Centrale, the agent works with me on a Jira ticket, from the plan to the PR. The code starts from the tests, two models review it, then I read it and sign it off before testing it in a dev environment or locally.

  1. Jira ticket
  2. plan
  3. TDD
  4. code
  5. simplification
  6. Claude review
  7. Copilot review
  8. my sign-off, a step I do myself
  9. test in dev or locally
  10. PR

Side projects: the agentic chain

On my side projects, specialised agents work through the tickets in Multica, a self-hosted tracker. I write the idea, I settle the spec and the ADRs, and nothing is merged without a green CI.

  1. idea, a step I do myself
  2. grill
  3. spec and ADRs, a step I do myself
  4. design
  5. tickets
  6. specialised agents
  7. review
  8. merge on green CI

in bluethe steps I do myself.

The chain, step by step

  1. Idea
    A page that describes the need, written by me.
  2. Market study
    Done only when the project targets users other than me.
  3. Grill

    An agent questions me over several rounds until the grey areas are settled.

  4. Spec and ADRs

    The spec and every decision that is hard to undo are written before the code.

  5. Design
    Design system and screens, approved before the first interface ticket.
  6. Tickets

    Independent tickets for each delivery step, with acceptance criteria that can be checked.

  7. Specialised agents

    Each ticket goes to a specialised agent (back end, front end, review, QA) in Multica.

  8. Review
    Another agent reviews the PR, and the fixes go back to the developer.
  9. Merge on green CI
    A PR merges only when review, QA and CI are all green.

Guardrails

A coding agent moves fast, including in the wrong direction. These guardrails are written down, and automated where possible, so that no change gets through on a model's word alone.

  • Pre-commit hooks: build, types, tests, lint and CDK synth block non-compliant code before the commit.
  • Review by two models: Claude then Copilot review every change before I do.
  • Human sign-off: no PR goes out until I have read and approved it.
  • Review agents without git write access: only the orchestrator publishes, once I have approved.
  • Impact analysis: before a review is summed up, the agent maps what the change touches.

What I decide, what the agents write

The line comes down to one rule: the agents write, I decide what ships.

I decide

  • the need and the scope
  • the architecture decisions, written as ADRs
  • what gets merged or published
  • the figures on display, always with a source

The agents write

  • the code and the tests, from the tickets
  • the first drafts of the docs
  • the PR reviews, which I read

Limits I ran into

  • An agent must not fill a gap in the information. When a fact is mine to give, the ticket waits for my answer instead of an estimate.
  • An agent's review flags, it does not fix: an edge case found in a colleague's PR goes back to them.
  • The review skill is never finished. I adjust it after each review, based on what it missed.

Projects delivered this way

All projects