A Claude Code plugin for the discipline of forward-deployed engineering: reconcile what the client actually said, pick the right lane to build in, ship a real prototype, and hand it off clean — instead of improvising all four.
$ brew install jq $ claude plugin marketplace add htecgroup/fde $ claude plugin install fde@fde-internal
Not a checklist bolted on after the fact — the sequence a prototype actually has to move through, with each stage's output feeding the next.
Raw transcripts, notes, and shared docs become a structured evidence base — sources, claims, contradictions, and the open questions that actually matter.
The lane, the hosting, and the auth model get picked from what the evidence supports — and written down, not carried in someone's head.
A golden-path template, a local dev environment, a CI pipeline, and a deploy target — wired together from the start, not assembled the night before the demo.
A dossier the receiving team can actually trust: the API surface, the data model, the decisions made, and an honest account of what still isn't production-ready.
Before any code exists — because the two lanes trade speed for durability in opposite directions, and mixing them up is how a demo becomes a liability.
Built purely for speed, on the understanding that it gets thrown away.
Built to be inherited, constrained to what the receiving team can absorb.
Most skills reach for themselves when the moment calls for them. The ones that close a gate never do — a person invokes those deliberately, at a specific point in the flow.
Forms an honest best guess from whatever exists before the first conversation — and names what is still unknown.
Researches how the problem is already solved elsewhere, and where nobody solves it well.
Turns those findings into questions someone can actually ask out loud, in the right order.
Reconciles several people's notes into one record, and preserves exactly where the picture is contested.
Resolves the contradictions and commits to a view of the problem — then revises it when the build disagrees.
Ranks what to build first by what would invalidate everything else if it turned out wrong.
Drives the running prototype as one of the client's actual users, and reports what broke.
Drives it as the person hardest to convince, so the objection lands before the demo does.
Creates the engagement workspace and the editor config for reading it as a graph.
Turns raw client material into a structured evidence base.
Preps, supports, and debriefs the requirements interview.
Picks the lane, hosting, and auth model — and records why.
Decides where the data comes from, models the domain once, and generates the rest from it.
Decides whether grounding is needed at all, then builds and tunes it against real test cases.
Decides when an integration should be something the model can call, and draws that boundary.
Shapes a multi-step agent and the point at which a human has to approve before it acts.
Makes the prototype explain itself when an answer is wrong and the logs don't say enough.
Settles the visual brief — theme, palette, layout — then turns approved scope into screens, each connected to real data rather than to a copy beside it.
Stands up the local dev environment for the lane in play.
Wires the CI pipeline that builds and publishes the image.
Configures the actual deployment target, whichever platform fits.
Maps the engagement, renders one architecture page from the decisions already recorded, and keeps every cross-reference honest.
Turns the evidence base into an approved spec, or an honest reason it isn't one yet — then into work items, in the repo or in your tracker.
Answers whether this is genuinely ready to show a client, and writes the script it gets walked from.
Records what the client decided — including a stop, which is the outcome most processes lose.
Packages the prototype for a handoff the next team can actually work from.
Takes a finished prototype's environment down on demand — keeping the record, revoking the access.
Reports where an engagement actually stands and what to run next — read from the workspace, never from memory.
Reads every decision the engagement has recorded and renders one page with diagrams — including, deliberately, what isn't real yet.
Builds one screen from a brief that names what it must demonstrate and which files are its own — several run at once, which is the point.
Reads a whole engagement workspace and returns only the conclusions — what exists, what is missing, what no longer resolves.
The marketplace cache and an already-installed copy update independently — pulling the latest commit doesn't reach a session that's already running, and an installed plugin doesn't notice a new commit until it's told to look.
$ claude plugin marketplace update fde-internal $ claude plugin update fde@fde-internal
Then restart the session — neither command applies to one already running.