AI-Agentic Development Unlocked for ABAP — ECC, S/4HANA, everywhere ADT is available.

ADT ↔ MCP Bridge: Gives Claude (and other AI assistants) full access to SAP ADT APIs. Read code, write code, debug, deploy, run tests — all through natural language (or DSL for automation).

See also: OData ↔ MCP Bridge for SAP data access.

Want to review or test? Start here: Reviewer Guide — 8 hands-on tasks, no SAP needed.

Read the milestone article: Agentic ABAP at 100 Stars: The Numbers, The Community, and What's Cooking

Sprint goal: make every token count. Built-in ABAP understanding, compressed dependency context, and a single-tool mode that opens the door for local/small models.

The full version history is in CHANGELOG.md.

Single SAP(action, target, params) tool replaces up to 122 individual tool definitions.

SAP(action="read",   target="CLAS ZCL_TRAVEL")
SAP(action="edit",   target="CLAS ZCL_TRAVEL", params={"source": "..."})
SAP(action="create", target="DEVC", params={"name": "$ZOZIK", "description": "New pkg"})
SAP(action="help",   target="debug")

All safety controls (--read-only, --allowed-ops, --allowed-packages) work identically — the universal tool routes through the same handler → ADT client → checkSafety() chain.

Thanks to Filipp Gnilyak for the hyperfocused mode concept.

GetSource auto-appends a compressed dependency prologue — public API signatures of every referenced class, interface, and FM. One MCP call = source + full surrounding context.

How it works:

graph LR
    A["GetSource<br/>ZCL_TRAVEL"] --> B["10 regex patterns<br/>scan source"]
    B --> C["TYPE REF TO<br/>NEW · => · ~<br/>INHERITING FROM<br/>INTERFACES<br/>CALL FUNCTION<br/>CAST · RAISING"]
    C --> D["Fetch deps<br/>5 parallel"]
    D --> E["Extract contract<br/>PUBLIC SECTION only"]
    E --> F["Source +<br/>Compressed Prologue"]

Compression by object type:

Real-world example — ZCL_ABAPGIT_ADT_LINK (abapGit codebase):

• 8 dependencies detected → 8 resolved, 0 failed
• Dependencies include: ZIF_ABAPGIT_DEFINITIONS (massive interface), ZCX_ABAPGIT_EXCEPTION, CL_WB_OBJECT (14 methods), IF_ADT_URI_MAPPER (8 methods), etc.
• All compressed to public signatures only — no implementation bodies, no private sections

Why pull an entire 1000-line class when you only need one 30-line method?

# Read just the FACTORIAL method — not the whole class
SAP(action="read", target="CLAS ZCL_CALCULATOR", params={"method": "FACTORIAL"})

# Edit just that method — vsp handles the rest
SAP(action="edit", target="CLAS ZCL_CALCULATOR", params={
  "method": "FACTORIAL",
  "source": "  METHOD factorial.\n    ...\n  ENDMETHOD."
})

What happens under the hood on edit:

sequenceDiagram
    participant LLM as AI Agent
    participant VSP as vsp
    participant SAP as SAP System

    LLM->>VSP: SAP(edit, CLAS ZCL_FOO, method=BAR, source=...)
    VSP->>SAP: GetClassMethods() → find BAR boundaries
    VSP->>SAP: GetClassSource() → full class
    Note over VSP: Replace lines 42-58<br/>with new METHOD block
    VSP->>SAP: SyntaxCheck(full reconstructed source)
    VSP->>SAP: Lock → UpdateSource → Unlock → Activate
    VSP->>LLM: ✓ Method BAR updated, class activated

The AI only sends/receives the method block (~30 lines). vsp fetches the full class internally, splices in the new method at the right line range, validates, and pushes back. 95% token reduction vs full-class round-trips.

Context compression scopes to the method too — when reading a single method, dependency analysis runs on that method's code only, so the prologue contains exactly the types and interfaces relevant to the method you're working on, not the entire class's dependency tree.

Built-in ABAP parser based on abaplint by Lars Hvam — the same parser that powers abaplint's 392 ABAP statement types.

The abaplint lexer has been mechanically ported from TypeScript to native Go (pkg/abaplint). This is the same lexer that powers abaplint — 48 token types, all 6 lexer modes (normal, string, backtick, template, comment, pragma), with full whitespace-context encoding.

Verified via oracle-based differential testing against the real TypeScript abaplint:

=== DIFFERENTIAL KPI ===
Files:   29/29 passed (100.0%)
Tokens:  22,612 total
  Full match:  22,612 (100.0%)  — str + type + row + col
  Str match:   22,612 (100.0%)
  Type match:  22,612 (100.0%)
  Pos match:   22,612 (100.0%)

Zero dependencies, zero FFI. Pure Go, ~3.5M tokens/sec, ready for lint rules in Phase 2.

vsp lsp --stdio gives Claude Code (and other editors) automatic error detection and navigation for ABAP files. No explicit tool calls — the LSP pushes diagnostics on every save and compressed dependency context on file open.

See LSP setup for configuration.

Compile WebAssembly binaries to native ABAP. Three paths, one goal:

.wasm binary → pkg/wasmcomp (Go)  → ABAP source files     ← AOT compiler
.ts source   → pkg/ts2abap (Go)   → clean OO ABAP classes  ← direct transpiler
.wasm binary → zcl_wasm_compiler  → ABAP (on SAP itself!)  ← self-hosting, 785 lines

Proven on SAP A4H: QuickJS (1,410 functions) compiled to 101K lines ABAP. abaplint parser (26.5MB) compiled to 396K lines. Self-hosting compiler parses WASM, generates ABAP, and executes via GENERATE SUBROUTINE POOL — all within SAP.

Branch: feat/wasm-abap. See reports/2026-03-20-001 for full details.

28 commands. No SAP GUI, no Eclipse, no IDE. Most work with standard ADT; lint/parse/compile work fully offline.

vsp query T000 --top 5                           # query tables
vsp grep "SELECT.*mara" --package '$TMP'          # search source code
vsp graph CLAS ZCL_FOO --direction callers        # who uses this class?
vsp deps '$ZFINANCE' --format summary             # transport readiness check
vsp lint --file myclass.clas.abap                 # offline ABAP linter
vsp compile wasm program.wasm --class ZCL_DEMO    # WASM→ABAP compiler
vsp parse --stdin --format json < source.abap     # ABAP parser
vsp context CLAS ZCL_FOO --depth 2                # compressed deps (2 levels)
vsp system info                                   # system version + ZADT_VSP check

graph and deps use WBCROSSGT/CROSS tables as fallback when ADT call graph API is unavailable — works on any SAP system with ADT.

See CLI Guide for the complete reference with feature requirements matrix.

• Lua Scripting Engine: vsp lua — interactive REPL + scripts with 50+ SAP bindings. Query tables, lint code, parse ABAP, debug with breakpoints, record execution, replay state. See example scripts.
• YAML Workflows: vsp workflow run pipeline.yaml — CI/CD automation with variable substitution, step chaining, and error handling. See example workflows.
• Bootstrap from CLI: vsp install abapgit + vsp install zadt-vsp — deploy dependencies to SAP systems directly from the command line. No SAP GUI needed.

# Download from releases
curl -LO https://github.com/oisee/vibing-steampunk/releases/latest/download/vsp-linux-amd64
chmod +x vsp-linux-amd64

# Or build from source
git clone https://github.com/oisee/vibing-steampunk.git && cd vibing-steampunk
make build

VSP works with 8 CLI coding agents — not just Claude! Full setup guides with config templates:

Full setup guide with config examples | Русский | Українська | Español

vsp works in two modes:

1. MCP Server Mode (default) - Exposes tools via Model Context Protocol for Claude
2. CLI Mode - Direct command-line operations without MCP

# Source operations
vsp -s a4h source CLAS ZCL_MY_CLASS              # read source
vsp -s a4h source read CLAS ZCL_MY_CLASS          # same, explicit
vsp -s a4h source write CLAS ZCL_FOO < file.abap  # write from stdin
vsp -s a4h source edit CLAS ZCL_FOO --old "X" --new "Y"  # surgical edit
vsp -s a4h source context CLAS ZCL_FOO            # source + dependency contracts
vsp -s a4h context CLAS ZCL_FOO                   # shortcut for above

# Search
vsp -s a4h search "ZCL_*"
vsp -s dev search "Z*ORDER*" --type CLAS --max 50

# Testing & code quality
vsp -s a4h test CLAS ZCL_MY_CLASS                 # run unit tests
vsp -s a4h test --package '$TMP'                  # package-level tests
vsp -s a4h atc CLAS ZCL_MY_CLASS                  # ATC code check

# Deployment
vsp -s a4h deploy zcl_test.clas.abap '$TMP'       # deploy file to SAP
vsp -s a4h export '$ZORK' '$ZLLM' -o packages.zip # export abapGit ZIP

# Bootstrap SAP system (no SAP GUI needed)
vsp -s a4h install abapgit                        # install abapGit
vsp -s a4h install zadt-vsp                       # install ZADT_VSP handler
vsp -s a4h install abapgit --edition full         # full dev edition (576 objects)
vsp -s a4h install list                           # show installable components

# Transport management
vsp -s a4h transport list                         # list transports
vsp -s a4h transport get A4HK900094               # transport details

# System management
vsp systems                                       # list configured systems
vsp config init                                   # create example configs

# Start ABAP LSP server (for Claude Code / editors)
vsp lsp --stdio

Configure multiple SAP systems in .vsp.json:

{
  "default": "dev",
  "systems": {
    "dev": {
      "url": "http://dev.example.com:50000",
      "user": "DEVELOPER",
      "client": "001"
    },
    "a4h": {
      "url": "http://a4h.local:50000",
      "user": "ADMIN",
      "client": "001",
      "insecure": true
    },
    "prod": {
      "url": "https://prod.example.com:44300",
      "user": "READONLY",
      "client": "100",
      "read_only": true,
      "cookie_file": "/path/to/cookies.txt"
    }
  }
}

Password Resolution:

• Set via environment variable: VSP_<SYSTEM>_PASSWORD (e.g., VSP_DEV_PASSWORD)
• Or use cookie authentication: cookie_file or cookie_string

Config Locations (searched in order):

1. .vsp.json (current directory)
2. .vsp/systems.json
3. ~/.vsp.json
4. ~/.vsp/systems.json

vsp --url https://host:44300 --user admin --password secret
vsp --url https://host:44300 --cookie-file cookies.txt
vsp --mode expert          # Enable all 122 tools
vsp --mode hyperfocused    # Single SAP tool (~200 tokens instead of ~40K)

export SAP_URL=https://host:44300
export SAP_USER=developer
export SAP_PASSWORD=secret
export SAP_CLIENT=001

# .env (auto-loaded from current directory)
SAP_URL=https://host:44300
SAP_USER=developer
SAP_PASSWORD=secret

Add to ~/.config/claude/claude_desktop_config.json:

{
  "mcpServers": {
    "abap-adt": {
      "command": "/path/to/vsp",
      "env": {
        "SAP_URL": "https://your-sap-host:44300",
        "SAP_USER": "your-username",
        "SAP_PASSWORD": "your-password"
      }
    }
  }
}

Add .mcp.json to your project:

{
  "mcpServers": {
    "abap-adt": {
      "command": "/path/to/vsp",
      "env": {
        "SAP_URL": "https://your-sap-host:44300",
        "SAP_USER": "your-username",
        "SAP_PASSWORD": "your-password"
      }
    }
  }
}

vsp includes a built-in LSP server that gives Claude Code automatic error detection when editing ABAP files — no explicit tool calls needed.

Add to Claude Code settings (.claude/settings.json or global settings):

{
  "lsp": {
    "abap": {
      "command": "vsp",
      "args": ["lsp", "--stdio"],
      "extensionToLanguage": {
        ".abap": "abap",
        ".asddls": "abap",
        ".asbdef": "abap"
      }
    }
  }
}

SAP credentials are resolved from environment variables or .env file — same as MCP mode.

Supported LSP features:

Supported file patterns (abapGit naming convention):

Namespace convention (#dmo#cl_flight.clas.abap → /DMO/CL_FLIGHT) is handled automatically.

To work with transportable packages (non-$ prefixed), you must explicitly enable transport support:

{
  "mcpServers": {
    "abap-adt": {
      "command": "/path/to/vsp",
      "env": {
        "SAP_URL": "https://your-sap-host:44300",
        "SAP_USER": "your-username",
        "SAP_PASSWORD": "your-password",
        "SAP_CLIENT": "001",
        "SAP_ALLOW_TRANSPORTABLE_EDITS": "true",
        "SAP_ALLOWED_TRANSPORTS": "DEVK*,A4HK*",
        "SAP_ALLOWED_PACKAGES": "ZPROD,$TMP,$*,Z*"
      }
    }
  }
}

CreatePackage with software component:

CreatePackage(
  name="ZPROD_005",
  description="Sub-package",
  parent="ZPROD",
  transport="DEVK900123",
  software_component="HOME"
)

Without these flags, operations on transportable packages will be blocked by the safety system.

One axis, three values — --mode or SAP_MODE:

graph LR
    F["focused<br/>81 tools<br/>~14K tokens<br/><i>default</i>"] --> E["expert<br/>122 tools<br/>~40K tokens"]
    E --> H["hyperfocused<br/>1 tool<br/>~200 tokens"]
    style H fill:#2d6a4f,color:#fff
    style F fill:#264653,color:#fff
    style E fill:#264653,color:#fff

vsp --mode focused       # default — 81 curated tools
vsp --mode expert        # all 122 tools individually
vsp --mode hyperfocused  # single SAP(action, target, params) tool

# ci-pipeline.yaml
name: CI Pipeline
vars:
  package: "$TMP"
steps:
  - action: search
    query: "ZCL_*"
    types: [class]
    package: "{{ .package }}"
    save_as: classes

  - action: test
    objects: "{{ .classes }}"
    parallel: 4

  - action: fail_if
    condition: tests_failed
    message: "Unit tests failed"

vsp workflow run ci-pipeline.yaml --var package='$ZRAY'

// Fluent search
objects, _ := dsl.Search(client).
    Query("ZCL_*").Classes().InPackage("$TMP").Execute(ctx)

// Test orchestration
summary, _ := dsl.Test(client).
    Objects(objects...).Parallel(4).Run(ctx)

// Batch import from directory (abapGit-compatible)
result, _ := dsl.Import(client).
    FromDirectory("./src/").
    ToPackage("$ZRAY").
    RAPOrder().  // DDLS → BDEF → Classes → SRVD
    Execute(ctx)

// Export classes with all includes
result, _ := dsl.Export(client).
    Classes("ZCL_TRAVEL", "ZCL_BOOKING").
    ToDirectory("./backup/").
    Execute(ctx)

// RAP deployment pipeline
pipeline := dsl.RAPPipeline(client, "./src/", "$ZRAY", "ZTRAVEL_SB")

See docs/DSL.md for complete documentation.

VSP supports full RAP OData E2E development since v2.6.0. Create complete OData services via AI assistant:

1. Create CDS View (DDLS)

WriteSource(
  object_type="DDLS",
  name="ZTRAVEL",
  package="$TMP",
  description="Travel Entity",
  source=`
@EndUserText.label: 'Travel'
@AccessControl.authorizationCheck: #NOT_REQUIRED
define root view entity ZTRAVEL as select from ztravel_tab {
  key travel_id as TravelId,
  description as Description,
  start_date as StartDate,
  end_date as EndDate,
  status as Status
}
`
)

2. Create Behavior Definition (BDEF)

WriteSource(
  object_type="BDEF",
  name="ZTRAVEL",
  package="$TMP",
  description="Travel Behavior",
  source=`
managed implementation in class ZBP_TRAVEL unique;
strict ( 2 );

define behavior for ZTRAVEL alias Travel
persistent table ztravel_tab
lock master
authorization master ( instance )
{
  field ( readonly ) TravelId;
  field ( mandatory ) Description;

  create;
  update;
  delete;

  mapping for ztravel_tab {
    TravelId = travel_id;
    Description = description;
    StartDate = start_date;
    EndDate = end_date;
    Status = status;
  }
}
`
)

3. Create Service Definition (SRVD)

WriteSource(
  object_type="SRVD",
  name="ZTRAVEL_SD",
  package="$TMP",
  description="Travel Service Definition",
  source=`
@EndUserText.label: 'Travel Service'
define service ZTRAVEL_SD {
  expose ZTRAVEL;
}
`
)

4. Create Service Binding (SRVB)

WriteSource(
  object_type="SRVB",
  name="ZTRAVEL_SB",
  package="$TMP",
  description="Travel OData V4 Binding",
  service_definition="ZTRAVEL_SD",
  binding_version="V4"
)

Add transport parameter to all WriteSource calls:

WriteSource(
  object_type="DDLS",
  name="ZTRAVEL",
  package="ZPROD",
  transport="DEVK900123",
  ...
)

• RAP OData Lessons Report
• DSL Pipeline: dsl.RAPPipeline(client, "./src/", "$PKG", "ZSRV_SB")

Run arbitrary ABAP code via unit test wrapper:

ExecuteABAP:
  code: |
    DATA(lv_msg) = |Hello from SAP at { sy-datum }|.
    lv_result = lv_msg.

Risk levels: harmless (read-only), dangerous (write), critical (full access)

See ExecuteABAP Report for details.

vsp enables AI assistants to investigate production issues autonomously:

User: "Investigate the ZERODIVIDE crash in production"

AI Workflow:
  1. GetDumps      → Find recent crashes by exception type
  2. GetDump       → Analyze stack trace and variable values
  3. GetSource     → Read code at crash location
  4. GetCallGraph  → Trace call hierarchy
  5. GrepPackages  → Find similar patterns
  6. Analysis      → Identify root cause
  7. Propose Fix   → Generate solution + test case

Example Output:

"The crash occurs in ZCL_PRICING=>CALCULATE_RATIO when LV_TOTAL=0. This happens for archived orders with no line items. Here's the fix..."

See AI-Powered RCA Workflows for the complete vision.

52 Focused Mode Tools:

• Search: SearchObject, GrepObjects, GrepPackages
• Read: GetSource, GetTable, GetTableContents, RunQuery, GetPackage, GetFunctionGroup, GetCDSDependencies
• Debugger: DebuggerListen, DebuggerAttach, DebuggerDetach, DebuggerStep, DebuggerGetStack, DebuggerGetVariables
  • Note: Breakpoints now managed via WebSocket (ZADT_VSP)
• Write: WriteSource, EditSource, ImportFromFile, ExportToFile, MoveObject
• Dev: SyntaxCheck, RunUnitTests, RunATCCheck, LockObject, UnlockObject
• Intelligence: FindDefinition, FindReferences, GetContext
• System: GetSystemInfo, GetInstalledComponents, GetCallGraph, GetObjectStructure, GetFeatures
• Diagnostics: GetDumps, GetDump, ListTraces, GetTrace, GetSQLTraceState, ListSQLTraces
• Git: GitTypes, GitExport (requires abapGit on SAP)
• Reports: RunReport, GetVariants, GetTextElements, SetTextElements
• Install: InstallZADTVSP, InstallAbapGit, ListDependencies

See README_TOOLS.md for complete tool documentation (122 tools).

vsp is a Go rewrite with:

• Single binary, zero dependencies
• 62 tools (vs 13 original)
• ~50x faster startup

vsp can optionally deploy a WebSocket handler to SAP for enhanced functionality like RFC calls:

# 1. Create package
vsp CreatePackage --name '$ZADT_VSP' --description 'VSP WebSocket Handler'

# 2. Deploy objects (embedded in binary)
vsp WriteSource --object_type INTF --name ZIF_VSP_SERVICE --package '$ZADT_VSP' \
    --source "$(cat embedded/abap/zif_vsp_service.intf.abap)"
vsp WriteSource --object_type CLAS --name ZCL_VSP_RFC_SERVICE --package '$ZADT_VSP' \
    --source "$(cat embedded/abap/zcl_vsp_rfc_service.clas.abap)"
vsp WriteSource --object_type CLAS --name ZCL_VSP_APC_HANDLER --package '$ZADT_VSP' \
    --source "$(cat embedded/abap/zcl_vsp_apc_handler.clas.abap)"

# 3. Manually create APC app in SAPC + activate in SICF
#    See embedded/abap/README.md for details

After deployment, connect via WebSocket to call RFCs:

{"id":"1","domain":"rfc","action":"call","params":{"function":"BAPI_USER_GET_DETAIL","USERNAME":"TESTUSER"}}

See WebSocket Handler Report for complete documentation.

# Build
make build          # Current platform
make build-all      # All 9 platforms

# Test
go test ./...                              # Unit tests (249)
go test -tags=integration -v ./pkg/adt/    # Integration tests (21+)

vibing-steampunk/
├── cmd/vsp/main.go           # CLI (cobra/viper)
├── pkg/adt/
│   ├── client.go             # ADT client + read ops
│   ├── crud.go               # CRUD operations
│   ├── devtools.go           # Syntax check, activate, tests
│   ├── codeintel.go          # Definition, refs, completion
│   ├── workflows.go          # High-level workflows
│   └── http.go               # HTTP transport (CSRF, auth)
├── internal/mcp/server.go    # MCP tool handlers (62 tools)
├── internal/lsp/             # ABAP LSP server (diagnostics, go-to-def)
└── pkg/dsl/                  # DSL & workflow engine

Automate debugging workflows with Lua scripts:

# Interactive REPL
vsp lua

# Run a script
vsp lua examples/scripts/debug-session.lua

# Execute inline
vsp lua -e 'print(json.encode(searchObject("ZCL_*", 10)))'

Example: Set breakpoint and debug

-- Set breakpoint
local bpId = setBreakpoint("ZTEST_PROGRAM", 42)
print("Breakpoint: " .. bpId)

-- Wait for debuggee
local event = listen(60)
if event then
    attach(event.id)
    print("Stack:")
    for i, frame in ipairs(getStack()) do
        print("  " .. frame.program .. ":" .. frame.line)
    end
    stepOver()
    detach()
end

Available Functions:

• Search: searchObject, grepObjects
• Source: getSource, writeSource, editSource
• Debug: setBreakpoint, listen, attach, detach, stepOver, stepInto, stepReturn, continue_, getStack, getVariables
• Checkpoints: saveCheckpoint, getCheckpoint, listCheckpoints, injectCheckpoint
• Diagnostics: getDumps, getDump, runUnitTests, syntaxCheck
• Call Graph: getCallGraph, getCallersOf, getCalleesOf
• Utilities: print, sleep, json.encode, json.decode

See examples/scripts/ for more examples.

┌─────────────────────────────────────────────────────────────────────────────┐
│  1. SET BREAKPOINT    →  2. RUN PROGRAM    →  3. CAPTURE CONTEXT           │
│     setBreakpoint()       (trigger via         saveCheckpoint()             │
│     on FM/method          unit test/RFC)       for each hit                 │
├─────────────────────────────────────────────────────────────────────────────┤
│  4. EXTRACT TEST CASES  →  5. AI NORMALIZE  →  6. GENERATE UNIT TESTS      │
│     inputs + outputs       deduplicate,         ABAP Unit classes           │
│     from checkpoints       explain patterns     with mocks                  │
└─────────────────────────────────────────────────────────────────────────────┘

-- Step 1: Set breakpoint on function module entry
local bpId = setBreakpoint("SAPL<FGROUP>", 10)  -- Entry point

-- Step 2: Prepare to capture multiple executions
local captures = {}

-- Step 3: Loop to capture test cases
for i = 1, 10 do
    local event = listen(120)  -- Wait for debuggee
    if not event then break end

    attach(event.id)

    -- Capture input parameters at entry
    local vars = getVariables()
    local testCase = {
        id = i,
        inputs = extractInputs(vars),  -- IV_*, IT_*, IS_*
        timestamp = os.time()
    }

    -- Step to end to capture outputs
    continue_()
    local event2 = listen(5)
    if event2 then
        attach(event2.id)
        testCase.outputs = extractOutputs(getVariables())  -- EV_*, ET_*, ES_*, RETURN
    end

    -- Save checkpoint for replay
    saveCheckpoint("testcase_" .. i, testCase)
    table.insert(captures, testCase)

    detach()
end

-- Step 4: Export for AI processing
print(json.encode(captures))

After capturing test cases, AI can:

1. Normalize & Deduplicate - Group similar inputs, identify unique scenarios
2. Explain Patterns - "TestCase 3 tests error path when IV_AMOUNT < 0"
3. Generate Unit Tests - Create ABAP Unit test class with proper mocks

User: "Analyze captured test cases and generate unit tests"

AI Workflow:
  1. Load checkpoints     → listCheckpoints("testcase_*")
  2. Analyze patterns     → Cluster by input signatures
  3. Identify edge cases  → Empty tables, zero values, error conditions
  4. Generate mock specs  → Which FMs/DB tables need mocking
  5. Create ABAP Unit     → ZCL_TEST_<FM> with test methods
  6. Deploy tests         → WriteSource to SAP system

Where we're going: TAS-style debugging, time-travel, AI-powered RCA

Read more:

• VISION.md - The dream: AI as a senior developer
• ROADMAP.md - Detailed implementation plan
• TAS & Scripting Report - Full technical design
• Test Extraction Report - Playground architecture

MIT

Contributions welcome! See ARCHITECTURE.md and CLAUDE.md for guidelines.