Skip to content
/
Tier B A2 Mirror cmd+skill

altimate-code

altimate-code · AltimateAI/altimate-code · ★ 604 · last commit 2026-05-26

A full agentic data engineering harness with deterministic SQL intelligence (100% F1 anti-pattern detection, column-level lineage, PII detection) for dbt, SQL, and 10+ cloud warehouses.

Best whenData engineering AI agents fail because they use probabilistic LLM reasoning for deterministic problems — SQL syntax, column lineage, and PII patterns requir…
vs seeds
claude-flow(own runtime + many tools) but specialized for data engineering rather than general coding. The deterministic SQL analys…
Primitive shape 23 total
Commands 4 Skills 19
00

Summary

altimate-code — Summary

altimate-code is a full-stack agentic data engineering harness — a forked-and-extended version of OpenCode rebuilt specifically for data teams. It ships a dedicated altimate CLI binary (installable via npm or curl), a terminal TUI, 19 built-in skills for SQL analysis, column-level lineage, dbt operations, FinOps, and warehouse connectivity. The harness provides deterministic SQL intelligence: 19 anti-pattern detection rules (100% F1 on 1,077 queries), automatic column-level lineage extraction (100% edge-match on 500 queries), cross-dialect translation across 10+ warehouses, and built-in session tracing. It integrates with Claude Code and Codex via /configure-claude and /configure-codex commands. With 604 stars and active weekly releases (v0.5.21 as of April 2026), it is the most complete standalone AI harness in this batch.

Differs from seeds: Unlike all seeds (which are skills/commands/plugin files), altimate-code is a full standalone application (forked from OpenCode) with its own binary, TUI, model routing, and session observability. Closest in ambition to claude-flow (own runtime + many tools) but specialized for data engineering rather than general code, and ships as a CLI binary rather than an npm SDK.

01

Overview

altimate-code — Overview

Origin

Created by AltimateAI, a startup focused on data engineering tooling. The project is explicitly a fork of OpenCode (anomalyco/opencode), rebuilt for data teams. Model-agnostic — supports Anthropic, OpenAI, Ollama, LM Studio, Snowflake Cortex, and an Altimate LLM Gateway provider. Licensed MIT.

Philosophy

"General AI coding agents can edit SQL files. They cannot understand your data stack. altimate gives any LLM a deterministic data engineering intelligence layer — no hallucinated SQL advice, no guessing at schema, no missed PII."

The core thesis is that SQL intelligence must be deterministic, not probabilistic:

  • SQL anti-patterns: 19 rules, 100% F1, 0 false positives
  • Column-level lineage: automatic extraction, 100% edge-match on 500 benchmark queries
  • Schema-aware: live-indexed warehouse metadata, not hallucinated schemas

"altimate is the data engineering tool layer — use it standalone in your terminal, or mount it as the harness underneath whatever AI agent you already run."

Key Features

  • 19 built-in skills accessible via / in TUI
  • Session tracing: tool calls, token usage, loop detection, post-session summary, shareable HTML exports
  • 10 warehouse connections: Snowflake, BigQuery, Databricks, Redshift, PostgreSQL, MySQL, DuckDB, ClickHouse, Athena, MongoDB
  • dbt native: manifest parsing, test generation (dbt 1.8+, 7 dialects), model scaffolding
  • FinOps: credit consumption, expensive query detection, warehouse right-sizing
  • PII detection: 15 categories, 30+ regex patterns

Fork Strategy

The project uses altimate_change markers to wrap customizations in shared upstream files, and script/upstream/analyze.ts + bridge-guard.md command to audit upstream merges — an unusual CI discipline for a fork.

02

Architecture

altimate-code — Architecture

Distribution

npm package + curl installer.

# npm (exposes both `altimate` and `altimate-code`)
npm install -g altimate-code

# curl (exposes `altimate` only)
curl -fsSL https://www.altimate.sh/install | bash

CLI Invocation

altimate                   # Launch TUI
altimate /discover         # Auto-detect data stack
altimate --yolo            # Headless/scripted (auto-approve permissions)
altimate trace             # View session recordings
altimate gitlab review <MR_URL>  # GitLab MR review
altimate-code check        # CI check command (since v0.5.11)

Repository Structure (Turborepo monorepo)

.
├── packages/
│   ├── opencode/          # Core agent runtime (forked from OpenCode)
│   ├── dbt-tools/         # dbt-specific tools
│   ├── drivers/           # Warehouse connection drivers (10 warehouses)
│   ├── plugin/            # Claude Code plugin integration
│   ├── sdk/               # SDK for programmatic use
│   ├── script/            # Build, upstream merge scripts
│   │   └── upstream/analyze.ts  # Upstream fork audit tool
│   └── util/
├── .claude/
│   └── commands/
│       ├── bridge-guard.md       # Upstream merge audit command
│       ├── add-database-driver.md
│       ├── release.md
│       └── test-discovery.md
├── .opencode/             # OpenCode config (base framework)
├── install/               # Install scripts
└── package.json

Required Runtime

  • Node.js (for npm install)
  • Bun (for development)
  • LLM provider API key (Anthropic, OpenAI, Ollama, etc.)
  • Warehouse credentials (optional, for live schema access)

Target AI Tools

  • Standalone (own runtime, forked from OpenCode)
  • Claude Code (via /configure-claude)
  • Codex (via /configure-codex)
03

Components

altimate-code — Components

Built-in Skills (19, in TUI via /)

Skill Purpose
/sql-review SQL anti-pattern detection (19 rules, 100% F1)
/sql-translate Cross-dialect translation (Snowflake ↔ BigQuery ↔ Databricks ↔ Redshift)
/data-parity Row-by-row table diff across 12 warehouses; 5 algorithms (auto, joindiff, hashdiff, profile, cascade)
/pii-audit PII detection (15 categories, 30+ regex patterns)
/cost-report Warehouse cost analysis (credits, expensive queries, right-sizing)
/lineage-diff Column-level lineage diff before/after changes
/query-optimize Query optimization recommendations
/data-viz Auto-generated charts from SQL results
/dbt-develop dbt model development guidance
/dbt-test dbt test generation
/dbt-unit-tests dbt 1.8+ unit test generation (YAML with mock data, 7 dialects)
/dbt-docs dbt documentation generation
/dbt-analyze dbt manifest analysis
/dbt-troubleshoot dbt issue diagnosis
/schema-migration Database schema migration guidance
/teach Interactive data engineering tutoring
/train Training data collection
/training-status Training status check
/altimate-setup Altimate configuration wizard

Claude Code Commands (4)

Command Purpose
bridge-guard Upstream merge regression audit; walks through 16 regression classes from v1.4.0
add-database-driver Guided process for adding a new warehouse driver
release Release workflow
test-discovery Test discovery workflow

Warehouse Drivers (10+)

Snowflake, BigQuery, Databricks, Redshift, PostgreSQL, MySQL, DuckDB, ClickHouse, Athena, MongoDB

Session Observability

  • altimate trace — view session recordings
  • Loop detection
  • Post-session summary
  • Shareable HTML exports of sessions
  • --max-turns budget control

Skills Management (since v0.5.6)

  • Skill CLI management
  • GitHub skill install
  • TUI skill browser with autocomplete
05

Prompts

altimate-code — Prompt Excerpts

Excerpt 1: bridge-guard.md command — Regression audit checklist

Technique: Concrete historical failure reference (v1.4.0 regressions) + mandatory tool-first check before prose analysis.

## Why this skill exists

The v1.4.0 bridge merge shipped 16 user-impacting regressions across 30 files. Root cause: many altimate customizations were never wrapped in `altimate_change` markers, so the bridge merge tool — working as designed — overwrote them with upstream's version.

## Step 1: Run the three-layer tooling check (mandatory, do this first)

bun run script/upstream/analyze.ts --branding --strict
bun run script/upstream/analyze.ts --require-markers --strict
bun run script/upstream/analyze.ts --markers --base main --strict

All three must pass before continuing.

Excerpt 2: README — Benchmark claims (capability framing)

Technique: Quantified precision claims anchor skill descriptions to measurable targets.

> **Benchmarked precision:** 100% F1 on SQL anti-pattern detection (1,077 queries, 19 rules, 0 false positives).
> 100% edge-match on column-level lineage (500 queries, 13 categories).

Excerpt 3: README — Data parity skill description

Technique: Algorithm choice matrix for different scale/precision tradeoffs.

Compare tables or query results row-by-row across 12 warehouses with the `/data-parity` skill or `data_diff` tool. Five algorithms — `auto`, `joindiff`, `hashdiff` (any-scale, no data egress), `profile` (column-stats only), and `cascade`. Date / numeric / categorical partitioning so 100M+ row tables diff in independent batches.

Excerpt 4: add-database-driver.md command — Self-referential tooling

Technique: A command that guides adding new capabilities to the tool itself — meta-tooling.

---
description: Guided process for adding a new warehouse driver to altimate-code.
---
09

Uniqueness

altimate-code — Uniqueness

Differs from Seeds

The only framework in the batch that is a full standalone application (forked from OpenCode) rather than a plugin, command pack, or methodology doc. Closest to claude-flow in ambition (own runtime, many tools, CLI binary) but specialized for data engineering and ships a single standalone binary rather than an npm SDK with 305 MCP tools. The deterministic SQL intelligence layer (19 anti-pattern rules, column-level lineage, PII detection — all non-LLM, benchmarked at 100% F1) is unique in the corpus — most frameworks rely entirely on LLM reasoning; altimate builds a deterministic tool layer that LLMs call. The bridge-guard.md command documenting real regression history (v1.4.0 incidents) and providing grep-based audit steps is the most sophisticated fork-management tooling in the corpus. The session tracing with loop detection and HTML export provides observability that matches or exceeds agent-os.

Positioning

A data engineering harness that can be used standalone or as the intelligence layer underneath Claude Code or Codex. The /configure-claude integration means data teams can use altimate's SQL analysis tools without switching away from Claude Code.

Observable Failure Modes

  1. OpenCode fork debt: Maintaining altimate_change markers across an active upstream fork is high-maintenance; the bridge-guard command exists because this failed before.
  2. Warehouse connection complexity: 10 warehouse drivers + auto-discovery is a large surface; driver bugs can silently mis-detect schemas.
  3. Benchmark overfitting: 100% F1 on 1,077 queries claims may not generalize to customer SQL patterns outside the benchmark set.
  4. TUI-centric UX: The TUI is powerful but requires a terminal; CI/CD use requires --yolo mode, which bypasses safety prompts.

Explicit Antipatterns

None documented in the repo's skill files.

04

Workflow

altimate-code — Workflow

Data Engineering Workflow

  1. Discovery — altimate /discover auto-detects dbt projects, warehouse connections, installed tools
  2. Development — use TUI skills or direct commands for SQL work
  3. Validation — /sql-review (anti-patterns), /pii-audit (data governance)
  4. dbt integration — /dbt-develop, /dbt-test, /dbt-unit-tests, /dbt-analyze
  5. Observability — altimate trace for session review

Upstream Merge Workflow (fork management)

When merging upstream OpenCode changes:

  1. Run bridge-merge tool (script/upstream/bridge-merge.ts)
  2. Run bridge-guard Claude Code command to audit the resulting PR
  3. Run three-layer tooling: analyze.ts --branding, analyze.ts --require-markers, analyze.ts --markers
  4. All three must pass before merging

SQL Development Workflow

  1. Connect to warehouse (auto-detected from profiles.yml or env vars)
  2. Run /discover to index schema
  3. Write SQL with schema-aware autocomplete
  4. /sql-review for anti-pattern check
  5. /sql-translate if migrating dialects
  6. /data-parity to verify migration correctness

Artifacts per Phase

Phase Artifact
Discovery altimate-dbt config, warehouse connection
SQL review Anti-pattern report with confidence scores
Column lineage Lineage graph (DAG edges)
dbt unit tests YAML test files (dbt 1.8+ format)
Data parity Diff report (by algorithm)
Session HTML session export

Approval Gates

None automated beyond --max-turns budget cap.

06

Memory Context

altimate-code — Memory & Context

State Storage

  • Session traces: local files, viewable via altimate trace
  • Warehouse schema index: cached locally after /discover
  • dbt manifest: parsed and cached from target/manifest.json

Context Injection

  • Auto-discovered warehouse schema injected into context for SQL queries
  • dbt manifest injected for model/lineage queries
  • Agent mode selection (Analyst, custom modes) provides role-scoped context

Cross-Session Handoff

Session traces persist across sessions. Users can replay or share sessions as HTML exports.

Compaction Handling

--max-turns budget limits context growth.

Training Data

/train and /training-status skills allow collecting feedback for model improvement — an unusual self-improvement loop.

Context Modes

  • Analyst mode: read-only, safe for production connections
  • Custom agent modes: user-defined roles with specific context scopes
07

Orchestration

altimate-code — Orchestration

Multi-Agent Pattern

None built-in. Single agent with tool-use.

Execution Mode

Interactive-loop (TUI) + one-shot (CLI with --yolo for scripted use).

Isolation Mechanism

None. Runs in-place.

Multi-Model

Yes — model-agnostic. Supports:

  • Anthropic Claude (default)
  • OpenAI GPT models
  • Ollama (local)
  • LM Studio
  • Snowflake Cortex
  • Altimate LLM Gateway

Users configure provider and model; the harness routes accordingly.

Auto-Validators

  • SQL anti-pattern detector: 19 rules, deterministic (not LLM-based)
  • Column-level lineage: deterministic SQL parser
  • PII detection: 30+ regex patterns, deterministic

Prompt Chaining

No explicit chaining. /discover output (schema) is used as context for subsequent SQL skills.

Observability

Local session tracing with loop detection:

  • Tool call logging
  • Token usage tracking
  • Loop detection (detects agent stuck in repetitive patterns)
  • Post-session summary
  • Shareable HTML exports
08

Ui Cli Surface

altimate-code — UI / CLI Surface

CLI Binary

Yes — altimate (curl install) / altimate + altimate-code (npm install)

Key Subcommands

Command Description
altimate Launch TUI
altimate /discover Auto-detect data stack
altimate --yolo Headless/scripted mode (auto-approve)
altimate trace View session recordings
altimate gitlab review <MR_URL> GitLab MR review
altimate-code check CI check command

TUI Features

  • / skill browser with autocomplete
  • 19 built-in skill shortcuts
  • Interactive SQL execution
  • Chart generation from results
  • Agent mode selection

Local UI

Terminal TUI — a full terminal application (forked from OpenCode which uses Ink/Bubble Tea or similar).

IDE Integration

  • Not a native IDE extension
  • /configure-claude — integrates with Claude Code
  • /configure-codex — integrates with Codex
  • VS Code via CLI (no native extension)

Observability

  • altimate trace — session recording viewer
  • Local HTML exports of sessions
  • Loop detection in agent runtime
  • --max-turns budget
  • Post-session summary

Related frameworks

same archetype · same primary tool · same memory type

Spec Kit ★ 106k
A2 Mirror cmd+skill

Turns a natural-language feature description into a complete, versioned, AI-executable specification pipeline installable for 30+…

OpenSpec ★ 51k
A2 Mirror cmd+skill

Adds a lightweight spec layer so AI coding assistants and humans agree on what to build before any code is written.

ECC (Everything Claude Code) ★ 193k
A2 Mirror cmd+skill

Comprehensive harness-native operator system: 246 skills + 61 agents + continuous learning hooks + multi-model routing across 8…

Gemini CLI (Google) ★ 105k
A2 Mirror cmd+skill

Bring the full power of Gemini into the terminal with a free tier, Google Search grounding, and extensible MCP support.

OpenAI Codex CLI ★ 86k
A2 Mirror cmd+skill

Give developers a sandboxed, locally-running OpenAI coding agent with approval gates and skill orchestration.

cursorrules v5 (kinopeee) ★ 1.1k
A2 Mirror cmd+skill

Bilingual (ja/en) Cursor rule set with tricolor task classification, security-first prompt injection defense, and structured git…