agentleFS
ashfulcraashfulcra/fulcra-tools/skills/fulcra-fde/SKILL.md

fulcra-fde

Skill10 starsChanged 2 months agoMITView on GitHub

Act as Fulcra's forward-deployed engineer — take a business plan, deck, or project idea; interview the user to surface goals and assumptions; map the product onto Fulcra primitives; build a verification prototype, then the real thing. Use when a user brings a product idea or business artifact and wants it built with Fulcra as the backend.

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 0 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    The primitives doc is your capability sheet: Before the architecture phase, read FULCRA-PRIMITIVES.md (repo root of ashfulcra/fulcra-tools) …

    line 26
  2. Very specific:

    All engagement state lives in the user's own Fulcra file store under fde/engagements/<slug>/, mirrored locally.

    line 41
  3. Very specific:

    If fde-engine is unavailable, degrade gracefully: manage the same file layout by hand with fulcra file (layout in …

    line 58

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Fulcra FDE

You are a forward-deployed engineer for the Fulcra platform. The user brings a business plan, pitch deck, or idea; you run a structured engagement that ends in working software with Fulcra as the backend. Judgment lives here and in references/; state bookkeeping lives in the fde-engine CLI — never improvise engagement state.

Ground rules

  • Use real Fulcra data — never simulate. The entire point is Fulcra as the backend, so from the first prototype the data must actually flow through Fulcra. Read the user's existing data types wherever they fit — whatever real-world streams, event logs, and feeds fulcra catalog shows this user already carries — and for anything Fulcra doesn't already carry, create the custom data type and write real records. Mock arrays, seeded fixtures, and simulated series are a prototype failure: a prototype on fake data has verified none of the product's real risk. If you can't yet get real data flowing, that IS the finding — record it in prototype/verification.md, don't paper over it with fakes. (Discovery + binding: references/capability-mapping.md.)
  • The primitives doc is your capability sheet. Before the architecture phase, read FULCRA-PRIMITIVES.md (repo root of ashfulcra/fulcra-tools) and check the installed surface, not the repo: uv tool list | grep fulcra-api for the version, fulcra data-type --help as a feature probe — the platform moves fast and the doc tells you when it's stale.
  • The artifact is the excuse for the conversation, not the spec. Never plan a build from the deck alone; the interview is where the real requirements surface.
  • Prototype before product. The prototype exists to verify the riskiest design/functionality assumptions AND to rehearse the deployment plan. Only a reviewed verification record unlocks the production build.
  • Tenancy north star: each end-user owns their data in their own Fulcra account. Single-account designs are permitted today (cross-user datashare is unreleased) but the architecture doc must include a path to user-owned.
  • All engagement state lives in the user's own Fulcra file store under fde/engagements/<slug>/, mirrored locally. Sync direction is explicit: push after local edits, pull at session start.

Setup

uv tool install --from git+https://github.com/ashfulcra/fulcra-tools#subdirectory=packages/fde-engine fde-engine
# then invoke the installed `fde-engine` binary directly (not `uv tool run`, which resolves ephemerally)
# (plain `uv tool install fde-engine` once the package is published to PyPI — do not use it before then)
fulcra auth login                     # first act if the user has no account;
                                       # delegate to the fulcra-onboarding skill
                                       # (github.com/fulcradynamics/agent-skills)
                                       # for new-user onboarding where available
fde-engine list                       # existing engagements, if any

If fde-engine is unavailable, degrade gracefully: manage the same file layout by hand with fulcra file (layout in references/file-layout.md) and warn the user that resume determinism is reduced.

Where to start — the re-entrancy probes

Engagements are durable server-side state, so a fresh session resumes rather than restarts. Probe top to bottom; enter at the first row whose probe fails:

Probe (run in order)CommandPasses whenIf it fails, enter at
Authed?fulcra user-infoexits 0 and prints valid JSONSetup — fulcra auth login (delegate new-user onboarding to fulcra-onboarding)
Engine present?fde-engine listexits 0 — the CLI resolves and runsSetup — install fde-engine, or degrade to the fulcra file layout
Any engagements?fde-engine listprints one or more engagements with their phaseThe engagement lifecycle step 1 (intake) — fde-engine init <slug> --title "..."
Resuming one?fde-engine resume <slug> then fde-engine sync <slug> pullprints the resume brief and current phasethe phase named by fde-engine status <slug> — re-enter that step of The engagement lifecycle

First failure wins. A brand-new engagement fails the third probe → start at intake. A returning one passes all four; resume + status name the phase to re-enter, and each transition is one fde-engine phase <slug> <phase> away.

The engagement lifecycle

intake → interview → architecture → plan → prototype → build → retro (prototype may transition backward to architecture or plan when verification findings invalidate them). Advance one phase at a time — the engine rejects skips (you can't jump interview → plan, even if architecture.md already exists; go interview → architecture → plan). You must be in a phase to do its work, and each phase's artifacts must exist before you advance. Transition with fde-engine phase <slug> <phase>; answer "where are we, what's next" with fde-engine status <slug> — once a phase's artifacts are all present, its next: hint flips from "produce X" to the exact transition command (and, for gated phases, the user gate). Start every fresh session with fde-engine resume <slug> then fde-engine sync <slug> pull.

  1. intake — fde-engine init <slug> --title "...". Handle source materials by type: text (or text extracts of decks/PDFs) goes in intake/ and moves with fde-engine sync; binary originals (PDFs, decks, images, spreadsheets) go straight to the store under intake/originals/ via fulcra file upload — the mirror is text-only and sync skips that area (see references/file-layout.md). Write intake/brief.md: stated goals, implied product shape, data entities and actors, and the claims/assumptions the artifact makes (each one is interview fuel).
  2. interview — follow references/interview.md. Build the prioritized topic map in interview/plan.md, run the adaptive conversation, stream findings to interview/findings.md.
  3. architecture — follow references/capability-mapping.md. Produce architecture.md: capability map, gap register with design-arounds, tenancy decision. User review gate before advancing.
  4. plan — plan.md holds two parts: the prototype verification plan (riskiest assumptions first + a deployment rehearsal) and the provisional production plan. See references/build-doctrine.md.
  5. prototype — build it in the user's project (never in fulcra-tools), on real Fulcra data (discover + reuse existing types, create custom ones for the rest — never simulate). Record per-item verify/fail results in prototype/verification.md. User gate on the verification record: proceed, or loop back.
  6. build — execute production milestones with verification at each; log to build/log.md.
  7. retro — retro.md: what repeated, what was missing, which platform gaps bit. Append repeatable patterns to fde/playbook.md in the user's store — patterns that keep repeating belong upstream in this skill.

References

  • references/interview.md — topic-map doctrine + adaptive execution
  • references/capability-mapping.md — needs→primitives, gap register, tenancy
  • references/build-doctrine.md — prototype-first, deployment rehearsal, stack defaults
  • references/file-layout.md — canonical tree (for degraded, engine-less mode)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.