Skip to content
tamir.consulting

Catch bugs before production. Keep your engineers on features.

I build the tests and checks that catch bugs before your customers do — then train an AI agent to keep them working after I leave. Releases stabilize. Firefighting hours go back into building.

Start a conversationSee how it works

fixed engagement · no new headcount · no subscription

refactor/payment-service → main#214

Split payment service out of the checkout monolith

  • lint & typecheck passed41s
  • unit 1,847 passed2m 04s
  • feature 312 passed4m 41s
  • e2e / checkout regression: duplicate charge on retry6m 12s

Merge blocked — 1 check failed

A regression caught minutes after it was written — not by a customer, days after it shipped.

A bug that makes it to production balloons in scope

A bug caught at the pull request is a five-minute fix. The same bug in production is a triage, a hotfix, and an apology to customers. Finding and fixing defects cost US businesses an estimated $407 billion in 2022.

Cost to fix the same defect grows by stage: a conversation during design, an edit during build, a failed check in testing and CI, a full incident in production. The engagement builds the gate before production.the gate this engagement buildsa conversationduring designan editduring builda failed checkin testing & CIan incidentin production

It compounds, too. Stripe's Developer Coefficient study found engineers lose about 42% of their week to debugging and maintenance. On a five-engineer team, that's two engineers working for the bugs instead of the roadmap.

The fix: a gate at the pull request that catches bugs in minutes — and an agentic system that keeps that gate current as your code changes.

One engagement. Four phases. A defined end.

I work directly in your codebase, in a fixed engagement scoped up front. It ends with a handoff, not a renewal.

The four engagement phases in order: deciding what to test first, building the tests, wiring them to block bad merges, training the agent last. At handoff my involvement ends and the agent plus your engineers continue indefinitely.handoff1 decide what to test2 build the tests3 block bad merges4 train the agent→ agent + your engineers, ongoing

  1. 1. Decide what to test

    We map the paths where a bug costs you money or trust, and put the tests there — not everywhere.

  2. 2. Build the tests

    Real tests against your real stack, living in your repo: fast checks on the logic, full walkthroughs of the flows that make you money.

  3. 3. Make them block bad merges

    Every pull request runs the tests; a failure blocks the merge. No CI yet? I build that too.

  4. 4. Train the agent

    I set up an AI agent on the system I just built — your patterns, your conventions — so the tests stay current after I leave.

After I leave, the agent does the upkeep. Your engineers keep the keys.

Tests rot: code changes, tests go stale, failures get ignored. The agent stops that — it updates tests as your code changes and writes new ones for new features, following the patterns I set. It works like any other contributor on your team, with less access.

The maintenance loop after handoff: your engineers ship code, the agent updates and writes tests, it opens a pull request, your team reviews and merges — repeating for every change.your engineersship codethe agent updates& writes testsit opens apull requestyour teamreviews & mergesevery change, for as long as you keep it

What stays in your hands

  • The agent only opens pull requests — your team reviews and merges every change.
  • Every test lives in your repo, in your git history — nothing locked in someone else’s dashboard.
  • You can cut its access at any time, with nothing to migrate.

Why not just…

…hire a full-time QA engineer?

A salary, a ramp-up, and know-how that walks out the door when they do.

This is a fixed cost with an end date — and the system stays.

…keep a contractor on retainer?

A contractor keeps your tests alive only as long as you keep paying.

The agent is what lets this end.

…buy an AI testing tool?

A generic tool guesses at code it has never seen.

This agent is trained on infrastructure and test patterns built for your codebase.

Start a conversation
Tamir Amitai

Built where failure wasn't an option

I'm Tamir Amitai, a QA and automation engineer. I came up building test systems and CI for production teams — Bank of America among them — where a bad release is never a minor incident. This engagement is that same rigor, pointed at a smaller, faster-moving team.

Every test the agent maintains started as something I wrote and shipped myself. The handoff works because there's real engineering underneath it — not because an AI figured out your codebase on its own.

Start a conversation

Tell me where bugs are costing your team the most. I read every message myself, and I'll tell you honestly whether this fits.

[email protected]

All fields are required.