RapidDoc AI
Automated Developer Documentation Engine
🏆 DT&A Digithon 2026 – Runner Up
A native code-to-text engine that turns raw codebases into structured technical docs, regenerated through CI/CD as code changes.
An asynchronous multi-agent pipeline with parallel fan-out routing that ingests large monolithic codebases, reverse-engineers architecture into instant HLDs, and generates Developer & User guides in Markdown, wired directly into CI/CD.
Engineering Brief
- My contribution
- Python static-analysis skills, the parallel agent pipeline, diagram synthesis, and CI/CD documentation generation.
- Engineering difficulty
- Separate code-derived structure from generated prose while coordinating parallel work across a large codebase.
- Outcome
- A production pilot with reduced documentation effort and faster onboarding.
Engineering questions
The Problem
Manual documentation constantly lagged behind code, creating stale docs, slow onboarding and accumulating documentation debt.
System Architecture
Architecture design
Illustrative paths, not live telemetry.
Architecture overview. No node selected.
Full network reference
Codebase
Monorepo
Kind: client
The repository is the source input. The local demonstration uses a bounded code fixture, not an internal monorepo.
Incoming (0)
None in this diagram
Outgoing (1)
- Static Analysisflow
Static Analysis
Python AST
Kind: api
Extract ASTs, imports, dependencies and call relations deterministically before language-model synthesis.
Incoming (1)
- Codebaseflow
Outgoing (1)
- Multi-Agentflow / index
Multi-Agent
Parallel fan-out
Kind: agent
Fan module work out to asynchronous agents, trading orchestration complexity for parallel processing.
Incoming (2)
- Static Analysisflow / index
- Azure OpenAIfeedback
Outgoing (3)
- Code → HLDflow
- Dev / User Guidesflow
- Sequence Diagramsflow
Azure OpenAI
Synthesis
Kind: agent
Generate prose from extracted code structure for engineering review.
Incoming (0)
None in this diagram
Outgoing (1)
- Multi-Agentfeedback
Code → HLD
Blueprints
Kind: service
Assemble a high-level architecture description from the extracted system structure.
Incoming (1)
- Multi-Agentflow
Outgoing (1)
- CI/CDdata
Dev / User Guides
Markdown
Kind: service
Produce Markdown developer and user guides alongside the architectural output.
Incoming (1)
- Multi-Agentflow
Outgoing (1)
- CI/CDdata
Sequence Diagrams
Mermaid
Kind: service
Synthesize Mermaid sequence diagrams programmatically from extracted relationships.
Incoming (1)
- Multi-Agentflow
Outgoing (1)
- CI/CDdata
CI/CD
Auto-commit
Kind: ops
Regenerate and commit documentation with code changes; failed jobs and uncovered modules can still leave gaps.
Incoming (3)
- Code → HLDdata
- Dev / User Guidesdata
- Sequence Diagramsdata
Outgoing (0)
None in this diagram
Live Demo
Follow a document: flow and evidence
A bounded browser parser and local templates produce this captured document. Source architecture links describe the project; no live agent, model, repository or ITSM system is called.
Analyze the input
Capture source text and locate definitions in the local fixture. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.
Extract signatures
Inspect parameters, types and return values extracted from the input. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.
Inspect responsibility
Name and body heuristics provide a bounded description for each symbol. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.
Generate documentation
Local language-aware templates turn the extracted records into docstrings or JSDoc. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.
Assemble the artifact
Combine function references and the component map into Markdown. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.
Review CI-ready output
Inspect the document before any repository integration. The output is ready for inspection. This browser demonstration does not commit files or submit an approval.
What I Engineered
- Engineered a native code-to-text translation engine that transforms raw codebases into structured technical documents.
- Architected an automated Code-to-HLD pipeline that reverse-engineers system architecture into instant design blueprints.
- Integrated into CI/CD to auto-generate Developer and User guides in Markdown on every change.
- Built deterministic Python static-analysis skills over ASTs, dependency graphs and call relations, plus programmatic Mermaid.js architecture and sequence-diagram synthesis.
- Designed an asynchronous multi-agent pipeline with parallel fan-out routing for large monolithic codebases.
Impact & Scale
- Reduced manual documentation effort by 60%+ (~15+ engineering hours saved per sprint)
- Accelerated technical onboarding and architectural alignment by 40%
- CI/CD regenerates documentation on code changes; semantic accuracy and completeness still require review
Evidence & Scope
The local code-to-document demo uses a small fixture to show static analysis, diagram synthesis, and document generation.
Source is HPE-internal and cannot be published. Architecture and trade-offs walked through on request.
Engineering Decisions
- 01
Fanned work out across asynchronous agents instead of one sequential pass.
A linear pipeline times out on large monorepos. Parallel fan-out by module trades orchestration complexity for the ability to document a big codebase in a single run: the only way the tool stays usable at real repo sizes.
- 02
Grounded generation in deterministic static analysis, not the model alone.
Imports, ASTs, dependency graphs and call relations are extracted by code and diagrams synthesised programmatically. The LLM writes prose over verified structure, so docs describe the real system rather than a plausible-sounding one.
- 03
Wired generation into CI/CD rather than a manual 'generate docs' step.
CI/CD makes regeneration part of a code change rather than a separate manual task. Failed jobs, uncovered modules and semantic inaccuracies can still leave gaps, so freshness checks and human review remain necessary.
Stack
- Python
- Extract ASTs, imports, dependencies and call relations before prose generation.
- LangGraph
- Fan module work out to coordinated agents rather than one sequential pass.
- Mermaid.js
- Synthesize architecture and sequence diagrams programmatically from extracted structure.
- CI/CD
- Trigger documentation regeneration alongside code changes.
Source is HPE-internal and cannot be published. Architecture and trade-offs walked through on request.
Related work
Shared engineering patterns across separate systems, not runtime dependencies.
- HPE OpsNexus
Both make system relationships explicit before synthesis: OpsNexus proposes traversal of an operational graph alongside retrieval; RapidDoc extracts dependencies and call relations from code.
Research design; prospective targets, not measured outcomes.
- Agentic AIOps Blueprint
Both extract structure deterministically before language-model authoring: infrastructure manifests for AIOps, code ASTs and dependencies for RapidDoc. Generated documents still need review.
Enterprise Internal
- GTMScale
CI/CD maintains different artifacts in each project: RapidDoc regenerates documentation on code changes; GTMScale tests and releases services.
Enterprise Production
Open to AI Software Development & Platform Engineering roles
Need someone who ships systems like this into production?