Fieldcraft

Ship whatyou asked for.

Field Kit. A framework for agentic delivery teams to stop building the wrong thing, fast.

Explore the skills

A skill for
every step.

Writing requirements good enough for an agent to build right is hard. An agent can turn a vague brief into working code before anyone’s checked it’s the right thing: invented requirements, scope that drifts past what was agreed, a “done” that just means it compiles. Field Kit gives you the skills to stay in the loop.

What’s actually the problem?

Separate a promising idea from the evidence behind it. Identify the buyer, the problem and the cheapest test that could change your mind.

Bring
An idea, research or customer observations.
Leave with
An opportunity packet with source passages, evidence gaps and a bounded experiment.

Confirmed vs. hoped

Before
Everyone we talked to loved the idea.
After
Confirmed: the problem is real for three people. Not yet confirmed: anyone will pay for it.

Try this with Field Kit installed

Use $field-kit-qualify to assess this idea. Separate evidence from assumptions and propose the cheapest useful experiment.

What haven’t we actually confirmed?

Read what is already known, then resolve the questions that change scope, behaviour or feasibility. Keep unanswered questions visible.

Bring
A rough brief and the existing product context.
Leave with
A short gap ledger and the smallest useful slice.

Found before it blocked anything

Before
Build the login flow.
After
One blocking question found before any code: does login mean email, SSO, or both? Everything else in the brief was already clear.

Try this with Field Kit installed

Use $field-kit-elicit on this brief. Inspect the existing project first, then ask only questions that materially change the next slice.

What exactly are we building?

Turn an agreed direction into requirements with a source, acceptance examples and a way to verify each behaviour.

Bring
Evidence, owner decisions and a bounded scope.
Leave with
A versioned build packet with traceable requirements.

A requirement you can test

Before
Make the dashboard faster.
After
Requirement: the dashboard loads in under 2 seconds for a logged-in user, traced to the original complaint, with a test that proves it.

Try this with Field Kit installed

Use $field-kit-compile to turn the agreed scope into a build packet. Link each requirement to its source and an observable acceptance scenario.

What does the plan miss?

Review the proposed work against the original evidence and actual code. Surface contradictions, missing behaviours and unsupported claims.

Bring
The build packet, its sources and relevant code.
Leave with
Actionable findings tied to the exact version reviewed.

A gap the spec missed

Before
The build packet looks complete.
After
Finding: the plan never says what happens when the API times out, a real gap in the actual code, not just the spec.

Try this with Field Kit installed

Use $field-kit-challenge to review this build packet against its evidence and the existing code. Separate blockers from advisory findings.

Does the work hold up?

Implement the approved slice and check its behaviour. Record the commands, results and version so the handoff can be inspected.

Bring
An approved build packet and its current review.
Leave with
A delivery handoff with requirement-linked verification.

Proof, not a claim

Before
Done, should be good.
After
Verified: the test ran, exit code 0, against this exact commit. That’s what shipped, not a claim that it works.

Try this with Field Kit installed

Use $field-kit-deliver for this approved slice. Run appropriate checks, record their actual results and identify any remaining verification gaps.

What happened in practice?

Compare the outcome with the original hypothesis. Use observed failures to improve the product or workflow, while preserving what was originally decided.

Bring
Real usage, experiment results and delivery evidence.
Leave with
An outcome record and a focused next change.

What actually happened

Before
It shipped, so it must be working.
After
Result: no one has actually used it yet. The fix isn’t more features, it’s finding that out first.

Try this with Field Kit installed

Use $field-kit-learn to compare these observed results with our original hypothesis. Keep technical success, customer usage and willingness to pay separate.

Follow the thread.

A repair note becomes a requirement, then a check: one small, fictional scenario showing the chain end to end, not a customer result.

Download the build packet

The source

opportunity.json: claim excerpt

{
  "id": "E-001",
  "sourceId": "SRC-001",
  "quote": "I want to record a short repair note so I can find it later.",
  "signal": "problem",
  "support": "supported"
}

A source passage stays attached to the claim it supports. It describes a problem; it does not establish willingness to pay.

Read the opportunity packet

The requirement

build.json: requirement excerpt

{
  "id": "FR-001",
  "statement": "Adding a non-empty repair note returns an ID and preserves its trimmed text for retrieval.",
  "origin": {
    "kind": "evidence",
    "id": "E-001"
  }
}

The build packet links this behaviour to the source claim, with persistence and authentication explicitly out of scope.

The check

Given
An empty repair log
When
A note containing surrounding spaces is added
Then
Its returned ID retrieves the trimmed note

The planned test maps back to this acceptance scenario. A real delivery still needs its execution result.

The review

review.json: review excerpt

{
  "packetId": "BUILD-001",
  "packetRevision": 1,
  "reviewer": "Fictional example reviewer",
  "findings": []
}

The full review also records the packet’s exact file hash. Change the packet and the old review no longer satisfies the readiness check.

Read the example review

Know what you’re using.

What’s in the kit?

Six skills, shared artifact schemas, templates, a worked example and command-line checks. The skills guide the work; the checks validate structure, references, review freshness and recorded verification.

Where does it run?

In your project, next to whatever coding agent you’re already using. It installs with a CLI and needs Node.js 22 or later for its checks.

What remains your call?

Whether the evidence is convincing, the scope is right and the work should ship. A passing check cannot prove customer demand or authenticate an approval. Field Kit keeps those decisions visible.

Can I use it today?

Field Kit isn’t a public install. We’re running it directly with a small number of teams, starting with one real feature. Get in touch to be one of them.

Put it to work.

Bring one feature that’s already headed for your coding agent. We’ll run it through Field Kit on that one piece of work, and you’ll see exactly where it changes the outcome.

Ask for access
Discuss a team setup