Step 4: Build

Part of: Business-First AI Framework

Where You Are

You’ve just finished Design (Step 3). You should have:

AI Building Block Spec ([name]-building-block-spec.md) — your approved blueprint with architecture approach, autonomy level, orchestration mechanism, step classifications, skill candidates, agent blueprints, and implementation order

If you’re returning from Test (Step 5) to fix issues, you may also have test results telling you which building block needs adjustment.

Prepare Context

Before the model generates any artifacts, you need to resolve the context your workflow depends on. The Context Shopping List (from Deconstruct) and the Data Readiness Summary (from Design) identify every document, file, and reference material the workflow needs — and flag which ones are available, which need to be created, and which need formatting.

Build begins by working through this list:

Find existing documents — Locate the style guides, templates, reference materials, and example files your workflow needs. These may live in shared drives, Notion databases, or on your local machine.
Create missing materials — Some context does not exist yet. A workflow that standardizes writing needs a style guide. A workflow that evaluates proposals needs scoring criteria. Create these now.
Format for AI consumption — AI works best with clearly structured text. Convert complex spreadsheets into Markdown tables. Extract relevant sections from long PDFs. Add headers and labels so the model can navigate reference materials efficiently.

Choose Your Build Path

The model offers two paths:

“I’ll build it” — The model generates all artifacts (skills, agents, prompts, configs) based on the approved spec. This is the default.
“I’ll build it myself” — The model provides a Construction Guide with build sequence, format references, and pointers to creation skills you can invoke — but you do the building.

Either way, the model starts by checking the Data Readiness Summary from your spec. Items flagged as “Partial” or “No” for AI accessibility are gated — they must be resolved (exporting data, granting access, reformatting files) before dependent steps can proceed.

Mechanism-Specific Build Paths

The orchestration mechanism determines which steps you follow. Work through only the steps that apply:

Create context — Build the context artifacts listed in your Building Block Spec’s Context Inventory
Set up project workspace (optional) — If the Building Block Spec’s Where to Run recommends a project
Generate platform artifacts — The model generates the prompt and any configuration needed for your platform

How the Model Builds for Your Platform

The model doesn’t guess your platform’s artifact format or available integrations. It uses a tiered research approach that starts with curated sources and supplements with web search:

Platform research:

Curated platform registry — The framework maintains a platform registry with documentation links, artifact format specs, platform mode (code vs. guided), and language for each supported platform. The model fetches this first to get authoritative format requirements.
Platform documentation — Using the doc URLs from the registry, the model reads the current artifact specifications for your platform — frontmatter schemas, file structure, naming conventions, and platform-specific extensions.
Web search (verification and fallback) — The model searches the web to verify that documentation is current and to find resources for platforms or features not yet in the registry.

Integration research:

Integration Options from Design — The Building Block Spec already identifies which integrations you need and includes source URLs discovered during Design’s Integration Discovery (which itself used the curated tool catalog, integration registries, and web search).
Platform-specific setup — For each integration, the model researches how to connect it on your specific platform: installation steps, configuration, authentication, and prerequisites.
Integration registries — The platform registry catalogs known sources for integration documentation (MCP registries, platform marketplaces, connector catalogs). The model checks these before falling back to web search.

Code vs. guided mode:

The platform’s mode (from the registry) determines what gets generated:

Code mode (Claude Code, Cursor, Codex CLI, etc.) — Source files: markdown skills, agent definitions, prompt files, MCP configurations
Guided mode (Copilot Studio, ChatGPT agent builder, etc.) — Step-by-step GUI instruction documents that walk you through configuring each building block in the platform’s visual interface

How Creation Tools Are Discovered

Before generating any artifacts, the model scans your environment for skills that can create other building blocks — a skill-creator, an agent-development skill, a prompt-engineering skill. It checks both the system-level skill list and platform-specific skill directories.

The model presents a Creation Tools Map showing which skills it found and which building block types they cover. When a creation skill is matched, the model delegates to it for higher-quality output (e.g., a skill-creator skill that includes eval, benchmarking, and optimization). When no match is found, the model generates inline using the format specifications from the platform registry.

You confirm the map before generation begins. If you have no specialized creation tools installed, everything still works — the model generates directly.

Your Role During Build

The model handles artifact generation, but several things require your involvement:

Context gathering. You know where your documents live, what your style guide says, and which examples best represent your standards. The model tells you what it needs; you provide it.

MCP connections. If your workflow uses external tools (CRM, calendar, databases), you configure the MCP connections that give the model access. The model tells you which connections are needed and provides setup instructions, but the actual configuration happens on your machine.

Agent platform setup. For agent-based workflows, you may need to create agents in your platform’s UI — uploading the agent definition the model generates. The model provides the configuration; you create the agent.

Track and Version Your Work

As you build, two background practices keep your work organized and recoverable:

Register building blocks in your AI Registry. Each time you create a skill, prompt, or agent, register it in your AI Registry Notion database — name, type, description, and which workflow it belongs to. If you registered the workflow during Deconstruct, these building blocks link back to it. This gives you a searchable inventory of everything you’ve built, and makes it easy for your team to discover and reuse building blocks across workflows.

Commit source files to GitHub. The .md files for your skills, agents, and prompts are source code — they should live in version control, not just on your local machine. After creating or updating a building block, commit it to your GitHub repository. This gives you a history of changes, makes it easy to share with collaborators, and protects against losing work.

These aren’t separate steps — they’re part of the rhythm of building. Each time you finish a building block: register it, commit it.

What This Produces

File	What it is
Platform artifacts	Prompts, skills, agents, and configs generated in whatever format your platform needs
Context artifacts	Style guides, reference materials, and examples — formatted for AI consumption
Tool connections	MCP connections and integrations configured on your platform

The Building Block Spec from Design is the design document — it captures what to build and why. The platform artifacts from Build are the implementation — generated by the model using your architecture decisions and current platform knowledge.

Many workflows stay at the prompt-plus-context level permanently — pasted into a chat whenever you need it. That’s a feature, not a limitation.

How to Use This

This step is facilitated by the build Business-First AI Framework skill. See Get the Skills for installation instructions across all supported platforms.

Start with this prompt:

Build the workflow from my approved AI Building Block Spec.

Upload or reference your Building Block Spec file ([workflow-name]-building-block-spec.md) from the Design step when prompted. The skill resolves context needs, generates platform artifacts, and prepares the workflow for testing.

Next Step

Once your artifacts are built, move to Step 5: Test to run structured evaluations before deploying.

Design Your AI Workflow — the step before Build
Test — the step after Build
Agentic Building Blocks — deep dives on individual building blocks
Agents & Skills — browse all available agents, skills, and prompts