Processes, Data, Systems

AI reads how each process actually runs today, in depth: which databases back it, which APIs it calls, which Excel files still carry data, and which imports run on a schedule. That reading produces the element list a later gap analysis works from, not an assumption about what the process should look like.

Gaps, MCP, Connections

AI compares that element list against the integration plan and names what is missing to fulfil it. Wrapping an existing API as an MCP server is one example: AI analyses the connection pattern first, so the wrapper matches how the API is actually called, not how it is documented.

Skills and Harness

From this data, skills get generated for what was found, and enriched with the patterns already in this practice’s skill catalogue. That combination is the harness the next phase, Agentic Implementation, builds against, instead of starting from a blank repository.

How the Read Becomes Skills the Next Phase Can Build Against

Read the Process in Depth 3 steps
01

Databases Behind the Process

Every process gets traced back to the database it actually writes to and reads from, table by table where that is knowable. That trace replaces a guess about the data model with what the running system actually holds.
02

APIs the Process Calls

Every API the process calls gets listed, along with which of its endpoints actually get used in daily operation and which never fire. That distinction matters more than the API's own documentation once an integration has to be built against it.
03

Excel Files and Scheduled Imports

Spreadsheets that still carry live data and imports that run on a fixed schedule get named individually, along with what feeds them and what reads from them. Each one is either a system of record in disguise or a gap the plan has to close.
Find What the Integration Plan Needs 3 steps
04

The Element List Against the Integration Plan

The element list from the reading gets checked against the integration plan, item by item, and every mismatch gets written down: a database with no read path, an API nobody wraps yet, an import with no destination in the new design.
05

Wrapping an API as an MCP Server

Wrapping an existing API as an MCP server is one route the gap analysis can point to. AI analyses the connection pattern the API is actually called with, so the wrapper matches real usage instead of the interface described in its documentation.
06

What Is Missing to Fulfil the Plan

Every gap found this way gets attached to the specific requirement in the integration plan it blocks, not left as a general observation. That attachment is what turns a list of gaps into work the next phase can actually pick up.
Turn Findings Into Skills 2 steps
07

A Skill for Each Finding

Each closed gap and each reusable connection pattern becomes its own skill: what it does, where it applies, and what fails if the assumption behind it turns out wrong. That skill outlives this one engagement.
08

Enriched With the Existing Catalogue

New skills get checked against the patterns already in this practice's skill catalogue, built up session over session on prior engagements. A matching pattern gets reused rather than rebuilt from nothing.
Enrich the Harness for the Next Phase 2 steps
09

The Harness the Next Phase Builds Against

The skills from this pass, old and new, become the harness the next phase starts from: the rules, the failure modes and the patterns already written down instead of a blank repository.
10

Handover Into Agentic Implementation

This phase ends with the element list, the gap list mapped to the integration plan, and the enriched skill set, ready for Agentic Implementation to build against without re-discovering what this pass already found.

Frequently Asked Questions

What does this pass actually hand over?
Three things. An element list naming the databases, APIs, Excel files and scheduled imports behind each process. A gap list, each entry mapped to the specific requirement in the integration plan it blocks. And a skill set, generated from the findings and enriched with the patterns in this practice's existing skill catalogue, ready for Agentic Implementation to build against.
How does the API-as-MCP-server example actually work?
AI analyses the connection pattern the API is actually called with, not its documentation, before anything gets wrapped. That pattern becomes the basis for the MCP wrapper, so it matches how the API is used in practice. Wrapping is one route the gap analysis can point to, not every gap turns into an MCP server.
Does this only work on code, or does it read business data too?
It reads whatever the process actually runs on: databases, APIs, Excel files carrying live data, and imports on a fixed schedule. None of that has to be code; a process that lives entirely in a spreadsheet gets read the same way as one behind an API.
Is the skill catalogue a separate project?
No, it runs in the same pass. New skills get checked against the patterns already in this practice's catalogue as they're generated, not reviewed afterward in a separate step. A matching pattern gets reused; a new one gets added to the catalogue for the next engagement.