[Sprinno Website](https://sprinno.xyz)

[CLI Documentation](https://sprinno.xyz/docs/cli)

[Methodology Whitepaper](https://sprinno.xyz/methodology)

[Pricing](https://sprinno.xyz/pricing)

[Use Cases](https://sprinno.xyz/usecases)

[Startup Beta Program](https://sprinno.xyz/startups)

[Contact / Request Access](https://sprinno.xyz/contact)

[Twitter / X](https://x.com/sprinnoxyz)

[LinkedIn](https://www.linkedin.com/company/trysprinno)

---

# Homepage

---
title: The SAT Score for Your Codebase | Sprinno

meta-description: Open-source code quality scanner. One command, real scores. Benchmark your engineering against companies at your stage.
---

## The SAT score for your codebase

One command. Real scores. See exactly how solid your engineering is, benchmarked against real companies at your stage. No sign-up required.

Primary CTA: npx @sprinno/scan

[BOOK A DEMO](https://cal.com/sprinno)

### How It Works

Terminal → Sprinno Engine → Quality Score

| Step | Component | What Happens |
|---|---|---|
| 1 | Terminal | Run npx @sprinno/scan in your project directory |
| 2 | Sprinno Engine | Scans codebase across 5 pillars using Latent Capability Scoring |
| 3 | Quality Score | Returns composite score (0-100) with pillar breakdown and .sprinno.json |

Everything runs locally. Source code is never transmitted.

### Key Metrics

| Metric | Value |
|---|---|
| Engineering pillars scored | 5 |
| Companies in reference benchmark | 200+ |
| Scan time | ~30 seconds |
| Sign-up required | No |
| Open-source | Yes (CLI scanner) |
| Code leaves your machine | Never |

### Features

- Verdict-First Quality Score: Composite score (0-100) across 5 pillars, weighted by empirical discrimination power.
- Flagged Anomalies: Surfaces the sharpest risk signal per scan. No noise.
- Cohort Benchmarking: Percentile rank against peers at same stage, sector, team size.
- Self-Healing (fix): Auto-fix findings with your own AI coding agent.
- Architecture Visualization: See how your software fits together.
- Historical Trends (Cloud): Track quality score over time across all pillars.
- Shareable Score Card: SVG card for READMEs, pitch decks, board reports.

### Who builds with Sprinno?

| Segment | Use Case |
|---|---|
| Developers & Engineering Teams | Honest picture of codebase quality. Find weak spots, track improvement, benchmark against peers. |
| Investors (Solo GPs, Micro-funds, Angels, VCs) | Deterministic technical risk scoring before writing a check. Replace $50K consulting engagements. |
| Startups & Founders | Improve engineering readiness score before fundraising. Show investors your engineering is strong. |
| Due Diligence Firms | Objective, reproducible assessments during fundraises and M&A. White-label reports with enterprise. |
| CTOs & Engineering Leaders | Track team quality over time, surface risks, demonstrate excellence to the board. |

### FAQ

Q: What is Sprinno?
A: Sprinno is an open-source code quality scanner that produces the first Latent Capability Scoring standard for measuring software engineering quality. Think of it as the SAT score for your codebase — an objective, reproducible measure of how well your team builds software.

Q: Is it really open-source?
A: Yes. The CLI scanner (@sprinno/scan) is fully open-source. Your code never leaves your machine — everything runs locally. The scanning engine, scoring logic, and quality ontology are all open. Sprinno Cloud (dashboards, percentiles, recommendations) is the paid product built on top.

Q: How do I get started?
A: Just run npx @sprinno/scan in your project directory. No sign-up, no repo connection, no config files. It runs locally in about 30 seconds and gives you a quality score across five engineering pillars.

Q: How does the scoring work?
A: We use Latent Capability Scoring (LCS) — our proprietary calibration algorithm that determines which metrics actually distinguish strong engineering from weak engineering. LCS assesses your code across five pillars and empirically weights each metric based on its discrimination power. Your score is contextual to your stage.

Q: Is my code safe?
A: Absolutely. The scanner runs entirely on your machine. We never see, store, or transmit your source code. Only anonymous quality scores (numbers, not code) are optionally sent to improve calibration. You can opt out entirely.

Q: Who is Sprinno for?
A: Developers and engineering teams who want an honest picture of their codebase quality. Investors and due-diligence firms also use Sprinno Cloud for objective assessments during fundraises and M&A.

Q: How is this different from static analysis tools?
A: Static analysis tools check code against fixed rule thresholds — deterministic but shallow. Sprinno assesses process maturity, architecture quality, resilience, and documentation. Weights are empirically derived from data across hundreds of repos, not arbitrary thresholds.

Q: What's the difference between the CLI and Sprinno Cloud?
A: The open-source CLI gives you a quality score, pillar breakdown, and a .sprinno.json file — all locally. Sprinno Cloud adds historical trends, percentile comparisons, full LCS-calibrated scores, team dashboards, and AI-powered recommendations.

Q: Can teams game the score?
A: Not easily. Weights are proprietary and empirically derived. The metrics that discriminate are ones requiring genuine engineering quality — you can't fake meaningful test coverage or healthy architecture.

Q: What tech stacks do you support?
A: Metrics are stack-agnostic at the pillar level. Whether you write Python, TypeScript, Go, Rust, Java, or anything else, we measure the same underlying engineering behaviors.

Q: How often does the model update?
A: The reference cohort grows with every new assessment. Parameters are recalibrated on a regular cycle. Scores become more accurate over time.

---

# Methodology

---
title: The Sprinno Methodology: The SAT for Code

meta-description: Sprinno applies Latent Capability Scoring, the same mathematical framework behind the SAT, GRE, and GMAT, to produce the first objective, reproducible standard for measuring software engineering quality.
---

## The Problem with Current Approaches

| Approach | Cost | Time | Consistency |
|---|---|---|---|
| Expert consultants | $30-80K | 2-4 weeks | Low, varies by assessor |
| Static analysis (SonarQube) | Low | Fast | High, but shallow |
| Equal-weight scorecards | Low | Fast | Misses what matters |
| Sprinno (LCS) | From $0 (open-source) | ~30 seconds | Deterministic, empirically weighted |

## Latent Capability Scoring (LCS)

The same class of mathematics used by the SAT, GRE, and GMAT to determine which questions genuinely distinguish strong students from weak ones. Applied to software engineering:

- Measure: Collect raw metrics from a reference cohort of repositories.
- Calibrate: Discover which metrics actually discriminate high-quality engineering from low-quality.
- Validate: Confirm metrics predict real-world outcomes (successful exits, failed startups, acqui-hires).
- Weight: Assign influence proportional to discrimination power.

Every new assessment grows the reference cohort, which recalibrates parameters, which improves discrimination.

> "What actually separates high-quality engineering teams from the rest, according to data?"
> — The question behind the Sprinno methodology

## The Five Pillars

Each pillar contains multiple sub-metrics weighted by empirical discrimination power.

### 01 — Code Health
The structural integrity of the code itself.
Metrics: Security posture · Test sophistication · Complexity indices · Dependency health

### 02 — Process Maturity
How disciplined the team's engineering workflow is.
Metrics: CI/CD depth · Review rigor · Commit discipline · Development velocity

### 03 — Architecture
Structural quality of the system design.
Metrics: Separation of concerns · Scalability patterns · API quality · IaC maturity

### 04 — Team Dynamics
How the team collaborates and distributes knowledge.
Metrics: Bus factor · Collaboration patterns · Onboarding readiness · Contribution equity

### 05 — Business Alignment
How well engineering serves business velocity.
Metrics: Deploy readiness · Tech debt management · Feature velocity · Incident response

## Stage-Aware Expectations

| Stage | Prioritizes |
|---|---|
| Pre-seed | Velocity, security basics, architecture foundations |
| Series A | Process maturity, testing discipline, scalability readiness |
| Series B+ | All pillars, incident response, team resilience |

## Scoring

| Score Range | Rating | Meaning |
|---|---|---|
| 90-100 | Exceptional | Top-tier engineering across all pillars |
| 75-89 | Good | Strong fundamentals with minor gaps |
| 60-74 | Fair | Functional but meaningful weaknesses exist |
| 40-59 | Concerning | Significant risk areas that need attention |
| 0-39 | Critical | Fundamental engineering issues present |

Percentile output: Your final score is a percentile rank against the reference cohort at your stage.
- P90 (Top 10%): Exceptional engineering for your stage
- P50 (Average): Typical for companies at this stage and sector
- <P25 (Concerns): Below peers — action required

## Bias Mitigation

| Factor | How It's Handled |
|---|---|
| Stack neutrality | Metrics normalized across languages and frameworks |
| Team size | Solo founders aren't penalized for low bus factor |
| Repo age | Young repos aren't punished for limited commit history |
| Context aware | Open source vs. private repos get different baselines |

## Ensuring Accuracy

- Deterministic pipeline: Same codebase, same score. Always. No human judgment, no sampling variation, no assessor bias.
- Empirical weights only: If a metric doesn't discriminate in practice, it gets minimal weight.
- Continuous self-improvement: Every new assessment grows the reference cohort and improves discrimination.

## Transparency

Same model as FICO, SAT, and every other trusted standard: you know exactly what is measured. The exact parameters stay proprietary.

Public (You Know):
- The five pillars and their sub-metrics
- The calibration approach (LCS)
- Scoring structure (percentile, stage-aware)
- Bias mitigation strategies

Proprietary (We Keep):
- Model architecture and parameter values
- Per-metric discrimination & difficulty
- Reference cohort composition
- Stage-specific weight matrices

## Comparison

| Dimension | Sprinno | Expert Consultants | Static Tools |
|---|---|---|---|
| Method | Latent Capability Scoring | Subjective assessment | Rule thresholds |
| Consistency | Deterministic | Assessor-dependent | Deterministic, shallow |
| Scope | 5 pillars, 20+ metrics | Varies | Code-level only |
| Calibration | Empirical, data-driven | Expert opinion | Fixed rules |
| Stage-aware | Yes | Sometimes | No |
| Improves over time | With every assessment | No | Manual updates |
| Cost | From $0 (open-source) | $30K-$80K/engagement | Varies |
| Time to result | ~30 seconds | 2-4 weeks | Minutes |
| Continuous monitoring | Yes (re-scores on merge) | No (point-in-time) | Partial |

Think SAT for academic readiness. FICO for creditworthiness. Sprinno for engineering quality.


---

# CLI Reference

---
title: CLI Documentation

meta-description: Complete reference for the @sprinno/scan CLI. All commands, flags, configuration options, and usage examples for the open-source code quality scanner.
---

## Installation

No installation required — run directly with npx:

  npx @sprinno/scan

Or install globally:

  npm install -g @sprinno/scan

## Commands

| Command | Description |
|---|---|
| scan (default) | Run a full quality scan on the current directory. Can be omitted. |
| setup | Re-run the onboarding wizard. Change stage, sector, or team size. |
| connect | Link CLI to Sprinno Cloud for LCS-calibrated scores, percentiles, trends, badges. |

## Flags Reference

| Flag | Type | Default | Description |
|---|---|---|---|
| --ci | boolean | false | CI mode. Disables interactive prompts, reads context from env vars. |
| --fail-below <n> | number | none | Exit code 1 if score below threshold. For CI gates. |
| --card | boolean | false | Generate shareable SVG score card (.sprinno-score.svg). |
| --json | boolean | false | Output results as JSON to stdout. |
| --quiet | boolean | false | Suppress terminal output. Still writes .sprinno.json. |
| --no-report | boolean | false | Disable anonymous score reporting for this run. |

## CI/CD Integration

  npx @sprinno/scan --ci --fail-below 60 --card

Exits 0 if score >= threshold, exits 1 if below. Reads context from env vars. Generates .sprinno.json.

## Environment Variables (for CI)

| Variable | Description |
|---|---|
| SPRINNO_STAGE | Funding stage (e.g., seed, seriesA, seriesB) |
| SPRINNO_SECTOR | Industry sector (e.g., fintech, healthtech, saas) |
| SPRINNO_TEAM_SIZE | Team size bucket (e.g., small, medium, large) |
| SPRINNO_TOKEN | API token for Cloud-connected scans |

## Configuration File (~/.sprinnorc)

  {
    "termsAccepted": true,
    "context": { "stage": "seed", "sector": "fintech", "teamSize": "small" },
    "reporting": true
  }

## Output: .sprinno.json

Generated on every scan. Machine-readable quality manifest for AI tools, CI pipelines, dashboards.

  {
    "$schema": "https://schema.sprinno.com/quality/v1",
    "version": 1,
    "overall": 67.4,
    "pillars": {
      "codeHealth": { "score": 72.8 },
      "processMaturity": { "score": 61.3 },
      "architecture": { "score": 68.0 },
      "resilience": { "score": 54.9 },
      "documentation": { "score": 70.1 }
    },
    "context": { "stage": "seed", "sector": "fintech", "teamSize": "small" }
  }

## Output: .sprinno-score.svg

Generated with --card flag. Shareable SVG score card for READMEs, social media, or presentations.

## Terminal Output Example

  $ npx @sprinno/scan
  Sprinno v1.0.0 — Code Quality Scanner
  Scanning directory: /home/dev/fintech-api
  Detected: TypeScript · NestJS · 847 files · 62K LOC

  🔒 Security scanner running...
  ⚠ 1 weak hash algorithm detected (MD5 in auth/legacy.ts)
  ✓ No secrets leaked · CORS configured · Helmet present

  🧪 Test coverage analysis...
  ✓ Coverage: 64% · Test ratio: 0.38 · CI present

  ⚙ Process maturity scan...
  ✓ Pre-commit hooks · Issue templates · Review signals

  🏗 Architecture analysis...
  ✓ Docker + IaC · Lock file present · 47 deps

  📖 Documentation scan...
  ⚠ Missing: CONTRIBUTING.md, Architecture docs

  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Overall Score: 67.4 / 100
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    Code Health      ████████████████░░░░  72.8  Good
    Process Maturity ████████████░░░░░░░░  61.3  Fair
    Architecture     █████████████░░░░░░░  68.0  Good
    Resilience       ██████████░░░░░░░░░░  54.9  Fair
    Documentation    ██████████████░░░░░░  70.1  Good

  ✓ .sprinno.json written
  ✓ Scan completed in 12.4s

## Telemetry & Privacy

By default, Sprinno sends anonymous quality scores (numeric only) to improve the LCS calibration model. Source code is never sent.

What's Sent:
- Numeric scores (0-100)
- Language & framework IDs
- Boolean pattern flags
- Repo shape (file count, LOC)
- Stage/sector context

Never Sent:
- Source code (zero bytes)
- File paths or names
- Commit messages
- Developer names/emails
- Repo name or org identity

Opt-out: Set "reporting": false in ~/.sprinnorc


---

# Pricing

---
title: Pricing

meta-description: Open-source code quality scanner. Upgrade to Sprinno Cloud for percentiles, trends, and team dashboards.
---

The scanner is open-source and runs locally. Upgrade to Cloud for trends, percentiles, and team features.

| Plan | Price | Includes |
|---|---|---|
| Open Source (Free) | $0 | Full 5-pillar scan, self-comparison deltas, monthly cohort calibration, fix auto-fixable, 2 fix needs-review/month. Community support. |
| Pulse | $19/month | Weekly calibration, 90-day cloud history, unlimited fix, trend sparkline, recommendations, score projections, live badge. Email support. |
| Pro | $49/month | Every-scan calibration, unlimited history, API access, all Pulse features. Priority support. |
| Team | $50/member/month | Everything in Pro + team dashboard, aggregate team score. Dedicated support. |
| Enterprise | Custom | Unlimited everything, SSO, white-label reports, dedicated support. For due-diligence firms, VCs, large orgs. |

## Feature Comparison

### Scanning & Calibration

| Feature | Free | Pulse | Pro | Team |
|---|---|---|---|---|
| Quality scan (5 pillars) | ✓ | ✓ | ✓ | ✓ |
| Self-comparison deltas | ✓ | ✓ | ✓ | ✓ |
| Cohort calibration | Monthly | Weekly | Every scan | Every scan |
| Cloud history | — | 90 days | Unlimited | Unlimited |

### Self-Healing (fix)

| Feature | Free | Pulse | Pro | Team |
|---|---|---|---|---|
| fix auto-fixable | ✓ | ✓ | ✓ | ✓ |
| fix needs-review | 2/month | Unlimited | Unlimited | Unlimited |

### Intelligence

| Feature | Free | Pulse | Pro | Team |
|---|---|---|---|---|
| Trend sparkline | — | ✓ | ✓ | ✓ |
| Targeted recommendations | — | ✓ | ✓ | ✓ |
| Score projections | — | ✓ | ✓ | ✓ |
| Live badge URL | — | ✓ | ✓ | ✓ |

### Team & API

| Feature | Free | Pulse | Pro | Team |
|---|---|---|---|---|
| API access | — | — | ✓ | ✓ |
| Team dashboard | — | — | — | ✓ |
| Aggregate team score | — | — | — | ✓ |

### Support

| Feature | Free | Pulse | Pro | Team |
|---|---|---|---|---|
| Support level | Community | Email | Priority | Dedicated |

---

# Use Cases

---
title: Use Cases

meta-description: How investors and startups use Sprinno, the SAT score for your codebase, to measure engineering quality objectively.
---

## The Investor's Blind Spot: Why Code Quality Kills Deals

Most seed investors fly blind on technical risk. A seed-stage investor reviews 200+ companies a year. Of those, maybe 15 get a term sheet. The technical evaluation for those 15? In most cases, it doesn't exist.

Traditional technical due diligence takes 3-6 weeks and costs $25,000-$75,000 per engagement — viable only for Series C+ deals. Sprinno connects to a repository and delivers a scored report within seconds, priced to run on every deal in a seed-stage pipeline.

### What Gets Missed Without Automated Scoring

- Entire product is one engineer's side-project codebase with no tests, no CI, credentials in plain text
- Bus risk: single-engineer knowledge concentration across all critical systems
- Copyleft and AGPL licence exposure creating legal risk
- Hardcoded credentials and exposed API keys
- Architecture that cannot scale past the current user count
- AI companies with no model evaluation methodology or training data provenance

### Pre-Investment Use

Run Sprinno on every deal in the pipeline. Get an objective score before the term sheet. Identify technical risk that pitch decks hide. Replace $50K consulting engagements with continuous, objective scoring.

### Post-Investment / Portfolio Monitoring

Unlike a static PDF report, Sprinno's risk score stays live and re-analyzes on every code change. A new vulnerability introduced on a Tuesday shows up before Wednesday — not at the next commissioned engagement.

---

# Startup Beta Program

---
title: Startup Beta Program

meta-description: Apply for Sprinno's Startup Beta Program. Get your SAT score for code, the first objective standard for measuring engineering quality.
---

Connect your repo. Get your technical readiness score. Show investors your engineering is as strong as your pitch.

## What You Get

| Benefit | Description |
|---|---|
| Technical Readiness Score | A single number that tells investors your code is production-grade. Updated continuously. |
| Investor-Ready Reports | Shareable reports that replace months of manual technical due diligence. |
| Actionable Fixes | Prioritized recommendations so you can resolve technical risk before it kills a deal. |

Status: Now Open — Apply at https://sprinno.xyz/startups


---

# Company & Contact

| Field | Value |
|---|---|
| Company | Sprinno |
| Website | https://sprinno.xyz |
| Email | aw@sprinno.xyz |
| Twitter / X | https://x.com/sprinnoxyz |
| LinkedIn | https://www.linkedin.com/company/trysprinno |
| Book a Demo | https://cal.com/sprinno |
| Terms of Service | https://sprinno.xyz/terms |
| Privacy Policy | https://sprinno.xyz/privacy |
| Cookie Policy | https://sprinno.xyz/cookies |

---

Sprinno © 2026, All Rights Reserved

<!-- last updated: 2026-08-26 -->