Lightning Forge

Multi-pass code validation with AI-powered fixing. Achieve perfect code quality with tiered validation depths tailored to your needs.

Validation Tiers

Choose the validation depth that matches your requirements. All tiers use multi-pass AI fixing until stability is reached.

🥉 Bronze

85%+

Quick validation

Syntax error detection
Basic linting (pylint, eslint)
Import validation
Multi-pass AI fix (until 3 no-change)
Documentation generation

🥈 Silver

95%+

Production ready

Everything in Bronze
Type checking (mypy, tsc)
Security scanning (bandit)
Multi-pass AI fix (until 3 no-change)
Code style enforcement
Documentation generation

RECOMMENDED

🥇 Gold

100%

Perfect quality

Everything in Silver
Knowledge base research
Best practice validation
Unlimited AI fix passes
Documentation generation
Test coverage analysis
Performance suggestions

Multi-Pass Convergence: Bronze and Silver tiers run AI fixes repeatedly until 3 consecutive passes produce no changes, ensuring stable output. Gold tier runs unlimited passes until 100% is achieved.

How It Works

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  Your Code  │ ──► │   Linters   │ ──► │  AI Analysis│ ──► │ Fixed Code  │
│             │     │ pylint,mypy │     │   Claude    │     │   100% ✓    │
│             │     │ flake8,etc  │     │             │     │             │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
                           │                   │
                           ▼                   ▼
                    ┌─────────────┐     ┌─────────────┐
                    │   Issues    │     │  Knowledge  │
                    │   Report    │     │    Base     │
                    └─────────────┘     └─────────────┘
                    
        Multi-Pass Loop: Repeat until 3 consecutive no-change passes (Bronze/Silver)
                         or until 100% achieved (Gold)

Validation Pipeline

Submit: Send code via API or Claude integration
Analyze: Run language-specific linters and type checkers
Research: Query knowledge base for best practices (Silver/Gold)
Fix: AI generates corrections for each issue
Iterate: Re-validate until convergence (3 no-change) or 100%
Document: Generate documentation for the code
Return: Clean code with docs and detailed fix report

Supported Languages

Language	Linters	Type Checking	Security
Python	pylint, flake8, ruff	mypy	bandit
JavaScript	eslint	tsc (via JSDoc)	eslint-security
TypeScript	eslint, tslint	tsc	eslint-security
Go	golint, go vet	built-in	gosec
Rust	clippy	built-in	cargo-audit
Shell/Bash	shellcheck	—	shellcheck
SQL	sqlfluff	—	sqlcheck
YAML/JSON	yamllint, jsonlint	schema validation	—

20+ languages supported in total

Per-User Configuration

Each user can configure their default tier and custom rules:

# User configuration stored in ITSM
{
  "user": "richard",
  "default_tier": "gold",
  "custom_rules": {
    "max_line_length": 120,
    "ignore_codes": ["W503", "E501"],
    "require_docstrings": true
  },
  "auto_fix": true,
  "notify_on_complete": true
}

Per-User Queues: Each user gets their own validation queue to prevent conflicts during concurrent sessions.

Custom Rulesets: Define project-specific linting rules and exceptions that persist across sessions.

Integration

Via Claude (Recommended)

# Claude automatically routes code through Lightning Forge
# Just write code normally - validation happens automatically

def calculate_total(items):
    return sum(item.price for item in items)
    
# Claude: "Code validated via Lightning Forge Gold - 100% score ✓"

Via API

curl -X POST https://forge.schomp.ai/validate \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "def hello(): print(\"world\")",
    "language": "python",
    "tier": "gold"
  }'

Related Products

Lightning MCP Platform - Infrastructure that powers Forge

Lightning Hive Mind - Distributed validation across AI nodes

Conjoined Twins AI - Twin-1 runs Forge validation