For a team with a working demo and no production path.

AI feature sprint

I build the feature into your product with guardrails, analytics and rerunnable checks. The scope and release bar are approved before code.

Scope your AI feature

The acceptance bar

  • Target: ≥ 95% happy-path success on the flows named in the scope.

    Run the agreed realistic inputs through the harness and save the scored results.

  • The routes the feature touches show no performance regression against the saved baseline.

    Compare saved measurements from before the work and before release.

  • Every event in the approved event plan fires under its agreed name.

    Exercise each scoped flow and check the events in your analytics.

  • The agreed guardrail cases block the outputs named in the scope.

    Run the saved unsafe-input and wrong-output cases and inspect the result.

  • Your team can rerun the feature checks and operate the feature from the handoff guide.

    Follow the guide in your environment and rerun the checks.

If a clause fails, the feature is not released. I fix the work within scope or you approve a scope change in writing.

This fits when

  • You have a named use case and a working demo.
  • Someone on your side can approve the scope and acceptance bar.
  • The feature belongs in a product and stack you already run.

What I will not build

  • AI exploration with no named use case
  • A model trained from scratch
  • An internal system with no written requirements
  • Crypto, gambling or adult content

From scope to handoff

  1. Define the scope

    I write the flows, exclusions and acceptance criteria before code.

  2. Approve the bar

    You approve the scope and the method used to check it in writing.

  3. Build in your repo

    I build in your repository against the approved scope.

  4. Check against the bar

    I run the agreed checks and save the results. A miss blocks acceptance.

  5. Hand over the work

    Your team gets the code, setup guide, results and a walkthrough.

What lands in your repo

  • The approved scope, flow list, event plan and acceptance criteria.
  • The feature in your repository, with loading, empty and error states.
  • Guardrail rules, rate limits and their configuration.
  • The rerunnable harness, saved failing cases and the scored report.
  • Analytics events, performance measurements and an operating guide.
  • At handover, the code is yours to the last line, with a clean handoff.

Before you send it

Will this fit our existing product?

I inspect your repository before scoping and build into your stack. The scope names the flows, model, events, guardrails and acceptance bar.

What happens if the scope changes?

I separate the new request from the approved work. You approve a scope change and its acceptance criteria before I build it.

Can I inspect the evidence?

DirectiveForge keeps a measure that got slightly worse in its public table. Dr.Acula is live in the iOS App Store; my active build ran Jan to Jun 2025, and its model billing dashboard is private.

Start with the flow

Send the flow, the product it belongs in and what counts as working. I return a scope, the acceptance bar and a handoff plan.

Scope your AI feature