Skills

Work

• Rebuilt a corporate retrieval system that was returning noise

  A search layer over ~1,100 internal documents was tuned with four hand-picked similarity thresholds. Whole classes of query scored so low that correct and incorrect answers were indistinguishable.

  Replaced whole-document embedding with passage-level indexing, fused lexical and semantic ranking with reciprocal rank fusion, and added a cross-encoder rerank on the top candidates. Deleted every hand-tuned threshold.

  On the queries that previously collapsed to near-zero relevance, scores went from ~0.02 to ~0.84. The system stopped needing a human to retune it.

  Python · PostgreSQL · vector search · cross-encoders

• Built an internal developer platform

  Shipping an application meant hand-editing GitOps manifests, clicking through ArgoCD, and knowing which of several clusters was the right one. Every deploy was a small act of tribal knowledge.

  Designed a CLI and API where the application declares its intent and the platform owns every side effect — GitOps commits, image promotion, rollout, rollback. Application teams never touch cluster state directly. JSON-first output so both humans and agents can drive it.

  Deploys became self-service. The platform, not a person, became the thing you ask when a rollout is stuck.

  Go · Kubernetes · ArgoCD · AWS · GitOps

• Built the system my own agents deliver through

  Running many coding agents at once is not a prompting problem. Without a designed shape the work collides on the same files, every agent asks the one human for permission it could have derived, and a day of visible activity finishes nothing. The failure mode is not bad output — it is unreviewable progress.

  Designed seven interlocking roles as executable contracts, each defined mostly by what it may not do: exploration that cannot create tickets, diagnosis that cannot become an approval stage, an implementer that owns exactly one mutable surface, an independent reviewer running on a different model, a peer consultation that advises without taking ownership, and a loop that backtests the workflow itself against real past runs. Work compiles into a small graph of outcomes where every node must justify its contribution; authority is granted per node instead of from a global matrix; state is always derived from the tracker, the pull requests and the checks, never mirrored into a second one.

  Parallel delivery that does not need watching. Agents run concurrently without colliding, and the human is interrupted for real decisions instead of for status. Most of what made it work was subtraction: no heartbeats, no coordination handshakes, no acknowledgements, no new gates.

  Agent orchestration · MCP · executable specs · Python

• Multi-tenant isolation for a data product

  A single-tenant system had to serve multiple customers whose data could not be allowed to mix, without a rewrite.

  Isolated tenants at the PostgreSQL schema and role level rather than with row-level security — a coarser boundary the database enforces itself, instead of one that depends on every query being written correctly forever.

  Cross-tenant reads became impossible at the engine level rather than unlikely at the application level.

  PostgreSQL · Go · AWS

• Debugged an evaluation pipeline everyone blamed on the model

  A nightly batch inference pipeline scored far below expectations. The consensus was that the judge model was simply not good enough.

  Instrumented the path between the pipeline and the model instead of tuning prompts. Found five separate defects in that path, each of which degraded output in a way that looked exactly like poor model judgement.

  Scores recovered without changing the model or the prompts. See `saitama_challenge` — this one is the puzzle.

  Python · LLM APIs · batch inference

• Private cross-environment networking

  Services in separate AWS environments needed to reach each other without traversing the public internet, and without a flat network that would undo the reason they were separate.

  Designed a PrivateLink-based topology: explicit, one-directional, per-service endpoints rather than VPC peering.

  Each connection is something someone deliberately granted, and is visible as its own resource.

  AWS PrivateLink · Terraform · Kubernetes

• This site

  A CV is a document you read. An agent asked about me has to scrape it, guess, and often invent.

  Made one origin serve five representations of the same corpus: an ASCII CV for terminals, a working shell for browsers, a stateless MCP server and an A2A endpoint for agents, markdown on request, and llms.txt for crawlers.

  You are reading one of them right now.

  Go · MCP · nginx · AWS · Cloudflare

What I believe

• Most 'the model is bad' conclusions are unexamined plumbing.

  Every layer between your process and the model's tokens can degrade output while returning a success code. Before you tune a prompt, prove the model received what you think you sent, and that you received back what it actually produced.

• A hand-tuned threshold is an undiagnosed bug with a config value in front of it.

  The number works on the data you had the day you picked it. It encodes an assumption nobody wrote down, and it silently stops being true. If a constant needs periodic retuning, the ranking underneath it is wrong.

• Isolation you have to remember to apply is not isolation.

  Row-level security depends on every query, forever, being written correctly by everyone who joins the team. A schema and a role boundary is coarser and less elegant, and the database enforces it whether or not anyone remembers.

• Retrieval quality is now a bigger lever on agent output than model choice.

  Swapping models moves results by a few points. Giving an agent the right passage instead of a plausible one changes whether the answer exists at all. Most teams are tuning the expensive knob.

• In agent work the scarce resource is human attention, so the system has to be designed around spending it.

  Compute is elastic and patience is not. Once enough work runs in parallel, every status update, every question whose answer was derivable, and every healthy heartbeat is a withdrawal from the one account that cannot be topped up. The rules that mattered most in my own delivery system are all refusals: never poll a healthy worker, never report internal state that is going fine, ask at most one blocking question at a time, and where a reversible assumption exists, state it and keep going.

• The unit of parallelism is the mutable surface, not the task.

  Two agents on separate tickets that edit the same file are one agent with a race condition. Decomposing by layer, by phase, or by anything other than what each unit is allowed to mutate produces a plan that looks parallel on the board and serialises the moment it runs.

• A role is defined by what it is forbidden to do.

  Every capable agent drifts toward becoming a coordinator: exploration starts filing tickets, diagnosis turns into an approval stage, a consultation quietly acquires ownership. The instructions that actually hold are the prohibitions, and most of the design work is deciding what a role must refuse even when it could do it competently.

• "Done" is not one state, and refusing to say which one is how delivery lies to you.

  Source ready, merged, integrated, and verified live are four different claims resting on four different kinds of evidence. A system that collapses them into one status reports the earliest and is understood to mean the latest — which is how an executor finishing gets mistaken for a delivery arriving.

• Improve a workflow from what its runs actually did, not from what its last failure felt like.

  A rule earns a change when the behaviour repeats across independent runs; one bad session is an anecdote with a strong emotional signature. And the burden is deliberately asymmetric — adding a guard needs a reason, removing one needs repeated proof that the guard itself causes the harm. People skipping it is not that proof.

• Never mirror state you could derive.

  A second tracker, a runtime manifest, a coordination ledger: each starts as a convenience and becomes an authority nobody elected. The moment it disagrees with the repository you are debugging the bookkeeping instead of the work. Rebuild the view from the sources that already have to be true, and let it stay ephemeral.

Ideas I'm chasing

• The CV becomes an endpoint — shipped — you are inside it

  Within a few years, being asked about is more common than being read about. The people who publish a queryable, first-party surface will be described accurately; everyone else will be described by inference. This site is the argument.

• Personal infrastructure as a practice — in progress

  The things we build for companies — deploys, observability, memory, retrieval — are worth building for a single person too, at hobby scale. Not for productivity. For continuity: so that what you learned survives the job where you learned it.

• Graph engineering and loop engineering — most of what I do now

  Two disciplines are appearing that nobody is hiring for by name yet. Graph engineering: designing the shape of the work — what fans out, what each unit is allowed to mutate, where authority is granted — so that many agents can run at once without colliding and without a supervisor. Loop engineering: designing the iteration itself, including the loop that improves the loop, from evidence of its own past runs rather than from intuition. Prompting is not the skill. The shape is the skill.

• Institutional memory should outlive the institution — an obsession

  Most of what a team knows is in Slack threads and someone's head, and evaporates on the last day. A corpus that captures the reasoning, not just the decisions, is the most undervalued artifact in engineering.

How I work

• Make the boundary something the system enforces, not something a reviewer remembers to check.
• If a threshold has to be hand-tuned, it is a bug that hasn't been diagnosed yet.
• When the model looks stupid, instrument the transport first.
• The goal of a platform is to stop being the person who knows how to run it.

Availability

closed — Not looking for anything right now. What is listed above is what would make me look — if that is what you have, write anyway.

curl saitama.sh

https://saitama.sh/mcp

Contact