Infinite Code Context: AI Coding at Enterprise Scale w/ Blitzy CEO Brian Elliott & CTO Sid Pardeshi

What It Covers

Brian Elliott and Sid Pardeshi explain how Blitsy achieves autonomous enterprise software development at scale by ingesting 100-million-line codebases, building domain-specific knowledge graphs, and orchestrating thousands of AI agents that complete 80-90% of major projects autonomously. They detail their architecture, model selection strategy, pricing at 20 cents per line of code, and path to 99% autonomous completion rates.

Key Questions Answered

• •Infinite Code Context Architecture: Blitsy creates programming language-agnostic knowledge graphs by building and running enterprise applications during ingestion, mapping line-level dependencies across 100-million-line codebases. This process takes several days of compute but enables precise context injection at runtime, pulling only relevant code into agent context windows while maintaining effective context below 100k tokens to avoid model degradation and context anxiety behaviors.
• •Dynamic Agent Generation System: All Blitsy agents generate dynamically at runtime rather than using hard-coded workflows. Agents write prompts for other agents, select tools just-in-time based on context, and reference latest model-specific prompting guidelines automatically. This dynamic design prevents depreciation as models improve, requiring only config file changes to integrate new models rather than rebuilding harnesses when capabilities or prompting best practices change.
• •Multi-Model Quality Strategy: Blitsy uses three model families (OpenAI, Anthropic, Google) with different models reviewing each other's work, producing demonstrably better results than same-family comparisons. Current assignments include Anthropic for first-pass code generation, OpenAI for structured output and code review, and Gemini for long-horizon task management. Different model families express researcher preferences in ways that complement each other when cross-validating outputs.
• •Spec-Driven Development Process: Blitsy converts fuzzy customer requirements into detailed technical specifications before code generation begins, spending significant time on planning and impact analysis rather than rushing to write code. The system returns future-state specs for human approval, identifying edge cases and affected services humans might miss across massive codebases. This mirrors elite developer behavior of planning thoroughly before implementation rather than immediately writing code.
• •Test-Driven Autonomous Execution: From approved spec to pull request, Blitsy runs completely autonomously with zero human intervention, performing unit tests before and after touching any file, integration tests between service clusters, and end-to-end testing while recursively self-correcting. The system runs actual enterprise applications in parallel environments during both ingestion and code generation, using build failures and runtime behavior to inform corrections rather than relying solely on static analysis.
• •Reasoning Budget Over Temperature: Modern reasoning models force temperature to one, shifting the control lever from temperature settings to thinking budget allocation. Models now perform internal reasoning loops before responding, essentially running multiple attempts with self-review during the thinking phase. Blitsy observes five to ten percentage point quality drops on benchmarks when thinking is disabled, with test-time inference becoming the primary driver of performance gains.
• •Memory Architecture for Enterprise Context: Long-term memory solutions must exist at the system layer rather than model weights because enterprise-specific knowledge is extremely locally contextual. Memory needs to capture decisions like which payment service to use in specific code clusters based on organizational contracts, not universal truths. Blitsy stores memory in execution traces and context management systems, learning from how enterprises express work preferences to improve future context injection decisions.