Skip to main content

Learn Path

The Learn Path is how ACE turns a complete mapping of your code and infrastructure into two products at once: Docs a human can read, and the grounding the Agents reason from. Same mapping, two audiences.

It is the concept behind the "Knowledge" side of the platform, and it is what makes the Software Factory AI actually understand your system instead of guessing.

The idea​

Before ACE can build or operate anything well, it has to know your system. The Learn Path builds that knowledge once and points it in two directions:

The same underlying map feeds both. When the map changes, both update.

Step 1: the full mapping​

The mapping is built by ACE's discovery process (the same steps in Feature Development):

  • Code mapping reads every connected repository and builds a map of files, languages, frameworks, and entry points.
  • Architecture synthesis turns that map into a written narrative of how the system fits together, plus a relationship graph.
  • Infrastructure discovery (cloud-hosted apps) inventories what's running in your cloud account and cross-references it with the code to produce an infrastructure map.

This is the "full mapping of code and infrastructure." Everything below is generated from it.

Step 2a: Docs (for humans)​

From the mapping, ACE generates readable documentation you browse, search, and edit:

  • Learning Paths, onboarding-style material derived from your actual code.
  • Book mode, the same content as a page-turning book with chapters.
  • Diagrams, architecture and data-flow diagrams rendered as real pictures.
  • AGENTS.md, short briefing files, one per key part of the codebase.
  • Unified Search, one search box across all of the above plus your code and any notes you add, using meaning-based (semantic) matching.

You can edit any of it, ask the AI to rewrite a section ("Fix with AI"), or add your own files. Edits re-index automatically, so search stays current.

Step 2b: Agents (the AI's grounding)​

The same mapping is what the Agents read when they work. It is layered by how it's used:

  • The architecture narrative is injected into every agent on every run, so the AI always has your system's shape in context.
  • The code map sits in a knowledge library the agents read on demand.
  • The AGENTS.md briefings give agents targeted context about specific parts of the codebase.

This is why a well-mapped project produces far better results: the factory's agents are grounded on your real system, not a generic assumption. Without the Learn Path mapping, the AI has nothing to reason from, as the product itself says: "If you haven't run Discovery, ACE has nothing to reason from."

Agents are also shaped here​

Beyond grounding, how ACE behaves is configured as part of this knowledge layer. You can tune how each specialist role approaches the work, which tools it may use, and which model it runs on, and add custom roles of your own, all per project. See AI Agents for what you can shape.

Why it's one concept, not two​

Docs and Agents are usually treated as separate things: documentation for people, prompts for the AI. ACE deliberately makes them one:

  • The docs a human reads and the context an agent uses come from the same mapping.
  • Fixing a doc improves the AI's grounding. Improving the mapping improves the docs.
  • There is no drift between "what the team believes about the system" and "what the AI believes," because they read the same source.

That shared source of truth is the Learn Path.

Where to go next​

AI AgentsHow the grounding produced here reaches each agent, and how agents are authored.Software Factory AIThe on-the-loop model the grounding serves.Map your codebaseRun the mapping step yourself on a sample project.
On this page