Skip to main content
The technical specifications represents Blitzy’s detailed understanding of each codebase’s architecture, patterns, conventions, domain terminology, and technical constraints. Toggle to Workspace to write generation prompts.
Jump to: Why • How • Example

​
Why the Knowledge Base Matters

The Knowledge Base serves as the foundation for high-quality AI-Native code generation. Here’s why it’s critical to operational success: Key capabilities:
  • Live documentation that automatically syncs with code changes
  • Repository and branch organization using {repo_name}/{branch_name} format
  • Structured 9-section specification format covering architecture to infrastructure
  • Seamless workspace integration for context review and code generation
  • Determines output quality -Well-documented specs produce accurate, contextually appropriate code matching your existing patterns
  • Reduces iteration cycles -Complete specs mean correct code on the first attempt, minimizing rework
  • Ensures architectural consistency -All generated code follows established patterns, preventing drift

​
Using the Knowledge Base

The Knowledge Base sidebar displays your complete technical specifications library with powerful filtering and organization:

Tech Specs Count

Total number of specifications you have access to, updating dynamically as you apply filters.

Filters

Narrow by VCS platform (GitHub, GitLab, Bitbucket), project name, or teams with access.

Naming Format

Each spec follows {repo_name}/{branch_name} format for instant context on repository and branch.

​
Browsing Specifications

Select any specification from the sidebar to view a comprehensive technical specification document. The spec opens with all 9 sections (Introduction through Appendices) fully expanded, providing deep context for effective generation prompts and understanding how new code integrates with existing patterns.
Read your tech spec. The better you know what Blitzy knows, the better the code it writes.

​
Search and Discovery

Within Specifications
  • Search for specific patterns, classes, functions, or architectural decisions
  • Navigate directly to relevant sections (e.g., jump to “System Architecture” or “Technology Stack”)
  • Find domain terminology in the Glossary (Section 9.2)
  • Review architecture diagrams in Quick Reference (Section 9.4)

​
When to Use the Knowledge Base

Review specifications before writing prompts to ensure you understand:
  • Current architectural patterns you should follow
  • Existing conventions for file organization and naming
  • Domain terminology to use in your requests
  • Technical constraints that must be respected

​
Getting Started

1

Access Knowledge Base

Toggle from Workspace to Knowledge Base using the UI toggle in the platform.
2

View Your Specifications Library

The sidebar shows your total tech specs count and all specifications in {repo_name}/{branch_name} format.
3

Apply Filters (Optional)

Use filters to narrow down by VCS, project name, or teams with access to find relevant specifications.
4

Select a Specification

Click any {repo_name}/{branch_name} entry to view its complete technical specification.
5

Review the Specification

Browse through the 9 sections: Introduction, Product Requirements, Technology Stack, Process Flowcharts, System Architecture, Components Design, UI Design, Infrastructure, and Appendices.
6

Navigate to Relevant Sections

Jump directly to sections like “System Architecture” (Section 5) for patterns or “Appendices” (Section 9) for glossary terms.
7

Search Within Specifications

Use search to find specific patterns, classes, or architectural decisions across all sections.
8

Apply Knowledge in Workspace

Toggle back to Workspace to create generation requests informed by your specification review.

​
Practical Example

You need to add a new payment processing feature to an existing e-commerce platform, but you’re unfamiliar with the codebase architecture. Here’s how the Knowledge Base helps:
1. Toggle to Knowledge Base -Access from the Workspace toggle; see total specs in the sidebar.2. Locate the Specification -Find ecommerce-platform/main in the sidebar or use “Filter by Project Name.”3. Review System Architecture (Section 5) -Learn the platform uses a three-tier architecture: Controllers → Services → Repositories. See PaymentGatewayService as the payment hub.4. Check Product Requirements (Section 2) -Review existing payment features, functional requirements, and implementation considerations for new payment methods.5. Consult Appendices - Glossary (Section 9) -Discover that “Order” and “Transaction” are distinct concepts; learn payment method types and fraud detection terminology.6. Examine Components Design (Section 6) -Review PCI-DSS compliance requirements, tokenization specs, and audit logging requirements.7. Study Process Flowcharts (Section 4) -Review payment processing workflows, error handling, and state management for transactions.8. Review Technology Stack (Section 3) -Check existing payment libraries, framework versions, and integration points with payment providers.9. Toggle Back to Workspace -Return with comprehensive understanding across all 9 specification sections.10. Create Informed Generation Request -Write a prompt referencing the three-tier architecture, correct domain terminology, PCI-DSS requirements, existing payment workflows, and the technology stack.
The specification review enables a high-quality generation prompt that produces code matching existing patterns on the first attempt, avoiding multiple refinement cycles.

​
Advanced Features

See all repositories in one view with {repo_name}/{branch_name} format. Filter by VCS platform (GitHub, GitLab, Bitbucket), team access, or project name. Understand how microservices relate to shared libraries across your organization.See the Git Submodules Integration Guide for configuration.

​
Best Practices

Before Every Generation

Review relevant specs, understand existing patterns, reference domain terminology, and check technical constraints before writing prompts.

During Code Review

Keep Knowledge Base open in a separate tab. Reference specs to validate generated code follows documented patterns and terminology.

Team Collaboration

Share spec links when discussing architecture. Reference Knowledge Base during planning meetings as shared vocabulary.

Specification Quality

Keep code well-organized, use .blitzyignore to exclude irrelevant files, and add meaningful comments explaining architectural decisions.

​
Troubleshooting

  • Verify you’re viewing the correct branch ({repo_name}/{branch_name})
  • Check that relevant files aren’t excluded by .blitzyignore
  • Use an ingestion prompt to provide business context and domain knowledge beyond static analysis
  • For submodules, ensure they are correctly synced with proper access granted
Use an ingestion prompt to improve specification quality by providing:
  • Business context and domain terminology
  • Compliance requirements (HIPAA, GDPR, SOC 2)
  • Architectural rationale and evolution
  • Guidance on what code patterns to focus on or ignore
  • Confirm branch exists in source control and is synced to remote
  • Verify you have access permissions for the branch
  • Check that branch isn’t excluded by repository configuration
Need help? Contact support at [email protected] or consult your Blitzy AI Solutions Consultant for Knowledge Base configuration assistance.