storm ingest: Drop AI Infrastructure Into Any Codebase

Every AI coding tool has a cold-start problem. You install it, point it at your codebase, and it knows nothing. No understanding of your architecture, your conventions, your module boundaries, your API surface. It starts from zero on every session.

storm ingest solves this. One command. No configuration. It analyzes your entire codebase, generates comprehensive documentation, and sets up the infrastructure that makes every future AI interaction dramatically more effective.

Phase 1: Deterministic Analysis

The first phase requires zero LLM calls. It is pure static analysis — fast, deterministic, and reproducible.

Language and framework detection. The ingest pipeline scans your project for package manifests, import patterns, configuration files, and build scripts. It identifies every language, framework, and significant dependency in use. Not just "this is a TypeScript project" — it knows you are using Next.js 16 with App Router, Drizzle ORM, and Tailwind v4.

Dependency mapping. Internal module dependencies are traced through imports to build a dependency graph. External dependencies are cataloged with version information. The result is a complete picture of how your code is connected.

Complexity scoring. Each module gets a complexity score based on cyclomatic complexity, dependency fan-out, file count, and code volume. This tells AI agents where to be careful and where simple changes are safe.

Convention extraction. The pipeline identifies naming conventions, file organization patterns, test structures, and code style by sampling existing code. These conventions become instructions that AI agents follow when generating new code.

Phase 2: Documentation Generation

With the analysis complete, the pipeline generates documentation in formats optimized for AI consumption.

Architecture document. A high-level overview of the system: what it does, how it is organized, what the major subsystems are, and how they interact. Includes Mermaid diagrams for visual architecture representation.

Module documents. Each significant module gets its own document describing its purpose, public API, internal structure, dependencies, and conventions. These are the documents that get loaded into context when an agent works in that module.

API documentation. REST endpoints, GraphQL schemas, RPC interfaces, and internal APIs are documented with request/response shapes, authentication requirements, and usage examples.

All generated documentation is Markdown, stored in your repository, and designed to be both human-readable and AI-parseable.

Phase 3: Infrastructure Setup

The final phase creates the scaffolding that makes AI agents effective in your specific codebase.

BRAINSTORM.md — The root project context file. Contains the architecture summary, build commands, key conventions, and any project-specific instructions. This is automatically loaded into every Brainstorm session that touches your project.

.agent.md per module — Scoped context files that provide module-specific instructions. When an agent works in packages/router/, it automatically gets the router's .agent.md with routing-specific context, not the entire project's documentation.

Recipes — Common task templates derived from your codebase patterns. "Add a new API endpoint" becomes a recipe with the exact file locations, naming conventions, and test patterns specific to your project.

No LLM Required

The most important design decision in storm ingest is that Phase 1 — the analysis — uses zero LLM calls. This matters for three reasons:

1. Speed. Static analysis of a large codebase takes seconds, not minutes. There is no API latency, no token cost, no rate limiting.

2. Reproducibility. Run it twice, get the same result. Deterministic analysis means you can commit the output and track changes over time.

3. Privacy. Your code never leaves your machine during analysis. The LLM only sees the generated documentation, not your raw source code.

Phase 2 (documentation generation) can optionally use an LLM for richer prose, but the default mode generates documentation from templates and analysis data alone.

One Command

``bash

storm ingest

`

That is it. Point it at any codebase — monorepo, single package, polyglot, legacy — and it produces the context infrastructure that makes every subsequent AI interaction faster, cheaper, and more accurate.

The cold-start problem is not a fundamental limitation of AI coding tools. It is a tooling gap. storm ingest` closes it.