Workflow Recipes¶

Twelve multi-step prompt recipes for common FCC workflows. Each recipe specifies the steps, the personas involved, and a code snippet to get started.

Table of Contents¶

Full Find-Create-Critique Cycle
ML Model Evaluation Pipeline
Governance Audit Workflow
Knowledge Graph Construction
Multi-Persona Literature Review
API Specification Workflow
Privacy Impact Assessment
Cross-Project Federation Setup
Champion-Led Research Package
Deployment Readiness Review
Open Science Publication Pipeline
Custom Persona Design Sprint

1. Full Find-Create-Critique Cycle¶

The canonical FCC workflow using the three core phases.

Personas: RC, BC, DE

Steps:

RC gathers research into a capability matrix and traceability matrix
BC transforms research into blueprints, API specs, and data models
DE reviews all deliverables against quality gates and style guides
DE provides feedback to RC and BC for iteration

from fcc.simulation.engine import SimulationEngine
from fcc.personas.registry import PersonaRegistry
from fcc._resources import get_personas_dir

registry = PersonaRegistry.from_yaml_directory(get_personas_dir())
engine = SimulationEngine(registry=registry, mode="mock")

trace = engine.run_workflow(
    workflow_id="base_fcc",
    scenario_id="GEN-001",
    personas=["RC", "BC", "DE"]
)
print(f"Workflow completed: {len(trace.steps)} steps")

2. ML Model Evaluation Pipeline¶

End-to-end model development from data sourcing through operations.

Personas: DSS, FAR, MAR, ESC, IOR, IRE, IAN, MOS

Steps:

DSS discovers and evaluates data sources with provenance checks
FAR designs feature store and transformation pipelines
MAR selects architecture and defines training strategy
ESC manages experiment tracking and hyperparameter sweeps
IOR optimizes the trained model for inference (quantization, distillation)
IRE generates explanations (SHAP, LIME, attention maps)
IAN measures real-world impact and monitors drift
MOS deploys to model registry with A/B test configuration

engine = SimulationEngine(registry=registry, mode="mock")
trace = engine.run_workflow(
    workflow_id="extended_84",
    scenario_id="ML-001",
    personas=["DSS", "FAR", "MAR", "ESC", "IOR", "IRE", "IAN", "MOS"]
)

3. Governance Audit Workflow¶

Comprehensive governance review using auditor and compliance personas.

Personas: GCA, DGS, PTE, AMS, KVC

Steps:

GCA defines audit scope and selects constitution tiers to evaluate
DGS reviews API contracts and data flow compliance
PTE classifies data elements against privacy taxonomies
AMS validates content for factual accuracy (anti-hallucination)
KVC performs key-value compliance checks
GCA compiles audit report with findings and remediation plan

from fcc.governance.constitution_registry import ConstitutionRegistry

const_registry = ConstitutionRegistry.load_default()
constitution = const_registry.get_constitution("GCA")
print(f"GCA constitution has {len(constitution.rules)} rules across {len(constitution.tiers)} tiers")

4. Knowledge Graph Construction¶

Build a domain knowledge graph from personas, actions, and artifacts.

Personas: OA, KB, SDE, STE

Steps:

OA designs the ontology schema (classes, properties, constraints)
STE builds taxonomy hierarchies and concept relationships
KB populates the graph with persona nodes, action edges, and artifact nodes
SDE implements serializers and SPARQL query interfaces

from fcc.knowledge.builders import build_full_fcc_graph
from fcc.knowledge.serializers import OWLSerializer

graph = build_full_fcc_graph()
serializer = OWLSerializer()
owl_output = serializer.serialize(graph)
print(f"Knowledge graph: {len(graph.nodes)} nodes, {len(graph.edges)} edges")

5. Multi-Persona Literature Review¶

Collaborative research synthesis using Find-phase personas.

Personas: RC, RIC, CIA, STE, RCHM

Steps:

RCHM orchestrates the review by defining scope and assigning sub-tasks
RC gathers primary sources and annotates with capability tags
RIC builds structured research inventories with automated evaluation
CIA creates searchable catalog indexes for all gathered materials
STE organizes findings into a semantic taxonomy
RCHM compiles the research package and hands off to BCHM

engine = SimulationEngine(registry=registry, mode="mock")
trace = engine.run_workflow(
    workflow_id="extended_20",
    scenario_id="RES-001",
    personas=["RCHM", "RC", "RIC", "CIA", "STE"]
)

6. API Specification Workflow¶

Design and validate API specifications with traceability.

Personas: BC, BV, TS, UMC, BCHM

Steps:

BCHM orchestrates the design sprint
BC creates API specifications with schemas, endpoints, and error handling
UMC produces UI mockups for any developer portal pages
BV validates specifications against quality gates
TS builds a traceability matrix from requirements to API endpoints
BCHM assembles the blueprint package

from fcc.workflow.action_engine import ActionEngine

action_engine = ActionEngine(registry=registry)
result = action_engine.run(
    persona_id="BC",
    action_type="scaffold",
    context={"task": "Design REST API for persona management"}
)
print(result.output)

7. Privacy Impact Assessment¶

Conduct a privacy review using privacy-focused personas.

Personas: PIA, CRM, DEO, PTE, DGS

Steps:

PIA performs a Privacy Impact Assessment, identifying data flows and risks
PTE classifies all data elements using privacy taxonomies
CRM maps consent requirements to data processing activities
DEO designs de-identification strategies for sensitive fields
DGS validates the complete privacy posture against regulations

engine = SimulationEngine(registry=registry, mode="mock")
trace = engine.run_workflow(
    workflow_id="complete",
    scenario_id="PRI-001",
    personas=["PIA", "CRM", "DEO", "PTE", "DGS"]
)

8. Cross-Project Federation Setup¶

Establish federation between two projects for shared knowledge.

Personas: OA, SDE, KB

Steps:

Register both project namespaces in the federation registry
OA maps vocabulary terms between projects
SDE builds cross-namespace edges in the federated knowledge graph
KB validates entity resolution confidence scores
Configure the change tracker for ongoing synchronization

from fcc.federation.namespace import NamespaceRegistry
from fcc.federation.resolver import EntityResolver

ns_registry = NamespaceRegistry()
ns_registry.register(namespace="project_a", display_name="Project A", base_uri="https://a.example.org/")
resolver = EntityResolver(namespace_registry=ns_registry)
matches = resolver.resolve("RC", source_namespace="fcc", target_namespace="project_a")

9. Champion-Led Research Package¶

Use the champion pattern to orchestrate a complete Find-phase delivery.

Personas: RCHM, RC, CIA, STE, RIC

Steps:

RCHM receives the project brief and decomposes it into sub-tasks
RC performs primary research with capability tagging
CIA indexes all gathered artifacts for searchability
STE builds semantic taxonomies from the research
RIC creates structured inventories with evaluation rubrics
RCHM assembles the unified research package and hands off to BCHM

champion = registry.get("RCHM")
print(f"Champion of: {champion.champion_of}")
print(f"Orchestrates: {champion.orchestrates}")

10. Deployment Readiness Review¶

Pre-deployment validation using DevOps and governance personas.

Personas: PBD, DVE, JUS, GCA, TS

Steps:

PBD reviews pipeline definitions and deployment configurations
DVE validates infrastructure-as-code and environment parity
GCA runs a compliance audit against deployment constitutions
TS verifies traceability from requirements through to deployed artifacts
JUS plans the rollout strategy (canary, blue-green, rolling)

from fcc.workflow.action_engine import ActionEngine

action_engine = ActionEngine(registry=registry)
result = action_engine.run(
    persona_id="DVE",
    action_type="test",
    context={"task": "Validate deployment configuration for production readiness"}
)

11. Open Science Publication Pipeline¶

Prepare research outputs for open access publication with FAIR compliance.

Personas: FDS, RSN, CSL, OAA, RC

Steps:

RC gathers all research artifacts and experimental data
FDS validates datasets against FAIR principles (Findable, Accessible, Interoperable, Reusable)
RSN verifies computational reproducibility of all results
CSL formats citations and resolves DOIs for all references
OAA guides repository selection, license choice, and embargo policy

engine = SimulationEngine(registry=registry, mode="mock")
trace = engine.run_workflow(
    workflow_id="complete",
    scenario_id="SCI-001",
    personas=["RC", "FDS", "RSN", "CSL", "OAA"]
)

12. Custom Persona Design Sprint¶

Create a new persona from scratch using FCC's design tools.

Personas: (you are the designer)

Steps:

Define the R.I.S.C.E.A.R. specification (all 10 components)
Create a 56-dimension profile using DimensionRegistry
Add cross-reference matrix entries for upstream and downstream interactions
Assign a constitution from the constitution registry (or create a custom one)
Register the persona as a plugin
Generate documentation using the DocGenerator
Write tests and validate with fcc validate

from fcc.scaffold.cli import cli
# Use the CLI to scaffold a new persona:
# fcc add-persona --id "MYP" --name "My Persona" --category "custom" --phase "Create"
# Then edit the generated YAML file to fill in all R.I.S.C.E.A.R. components.