https://github.com/dollspace-gay/ripsed
cosslink was used to build this from greeenfield to mvp in about an hour, here are claudes notes on what worked vs what didnt
Ripsed Build Retrospective
Project: Crosslink + Multi-Agent Fabrication of a Rust CLI Tool
Date: 2026-03-01
Tool under test: Crosslink (accountable AI development system)
Project built: ripsed — a fast, modern stream editor in Rust (4-crate workspace, 273 tests, full CI)
Build method: Multi-agent parallel implementation from a design document, human-supervised via Crosslink
Context
This project was built from nothing — a design document — to a working, tested, CI-enabled Rust tool in a single extended session. The goal was to evaluate Crosslink as a system for fabricating precision software, the kind of code that belongs in science labs, clinical pipelines, and instrument control — not disposable prototyping slop.
The comparison point is the "gastown" approach: yolo hundreds of agents, generate code fast, treat everything as disposable. Crosslink takes the opposite stance: every change is tracked, every session has handoff notes, the human controls all git writes, and quality gates are enforced by hooks.
What Crosslink got right
Accountability and traceability
Every change had an issue number. Every session had handoff notes. When Windows CI failures surfaced three distinct bugs (path escaping, file handle semantics, lock deletion), the fix history was clean and auditable:
Each had a focused commit with a clear message. For a lab shipping instrument firmware or processing clinical trial data, you can point an auditor at the issue trail and show exactly what changed and why. That traceability is non-negotiable for regulated environments.
Human-in-the-loop for git writes
The work-check.py hook blocks all git push, git merge, and other mutation commands. The human performs all git write operations. This caught real problems:
- The wave-1 worktree deadlock (6 agents all silently failed) never reached the remote
- The Windows bugs were caught and fixed before the PR was merged
- Every commit was reviewed before it left the machine
With a yolo approach, broken agents might have pushed garbage to main. Nobody would know which of the 100 agents introduced the broken lock test. Crosslink's overhead is the price of knowing what your software does and why.
Session continuity
The crosslink session end --notes "..." / crosslink session start handoff mechanism worked well across multiple sessions. When context was compacted or a new session started, the handoff notes provided enough state to resume without re-exploring the codebase. This is critical for multi-day projects where context windows are a real constraint.
Parallel agents with crate boundaries
The wave-2 launch of 4 parallel agents (core hardening, CLI completion, FS deepening, CI/benchmarks) all completed and merged cleanly. The 4-crate workspace architecture (ripsed-core, ripsed-fs, ripsed-json, ripsed-cli) gave natural isolation boundaries. Each agent worked on a different crate with minimal file overlap. This is the ideal case for parallel AI work: clear boundaries, shared interfaces, independent implementation.
What went wrong
Worktree hooks are broken (critical)
The wave-1 agents used --isolation worktree for safe parallel work. All 6 hit a hook deadlock because .claude/hooks/work-check.py uses git rev-parse --show-toplevel, which resolves to the worktree root — not the main repo where .claude/hooks/ lives.
This means the primary isolation mechanism for parallel agents (worktrees) is incompatible with the primary quality mechanism (hooks). For a precision-software tool, this is a critical bug: it forces you to choose between parallelism and quality enforcement, when you need both.
Recommendation: Hooks should resolve paths relative to the main working tree, not the current worktree. Or the hook setup should be copied/symlinked into worktrees automatically.
cargo fmt should be a pre-commit hook
Formatting was never enforced automatically. cargo fmt had to be run manually, repeatedly, and every commit needed a follow-up formatting pass. For a system selling itself on "no slop gets through," formatting should be non-negotiable and automatic.
A Crosslink pre-commit hook that runs:
cargo fmt --check
cargo clippy --workspace -- -D warnings
...would have caught formatting drift, deprecated API warnings, and clippy issues before they ever landed in a commit. This is low-hanging fruit that would significantly improve the out-of-the-box experience for Rust projects.
Recommendation: Add language-specific pre-commit quality gates to the Crosslink rule sets. For Rust: cargo fmt --check and cargo clippy at minimum.
Cross-platform issues were invisible until CI
Three distinct Windows failures surfaced only after pushing to CI:
-
Path separators in JSON: dir.path().display() produces C:\Users\... on Windows. Backslashes are JSON escape characters. Every test that embedded a path in a JSON string broke.
-
File handle semantics: On Windows, you cannot delete a file with an open handle (PermissionDenied). The lock file's release() method called remove_file while the File handle was still open. Linux allows this silently.
-
Both were invisible on the dev machine (Linux/WSL2). The CI matrix (Ubuntu, macOS, Windows) caught them, but only after the PR was created.
Recommendation: For projects targeting multiple platforms, the design document should include a "Platform Considerations" section. Cross-platform gotchas (path separators, file handle semantics, line endings) should be called out explicitly so agents can handle them from the start.
Agents don't write enough tests
Every agent-written module had test gaps. Five source files shipped with zero unit tests:
| File |
What it does |
Tests at ship |
Tests after review |
operation.rs |
Core Op enum, LineRange, OpOptions |
0 |
18 |
config.rs |
TOML config parsing and discovery |
0 |
11 |
error.rs |
Error taxonomy and factory methods |
0 |
16 |
response.rs |
JSON response building |
0 |
6 |
schema.rs |
Protocol version constants |
0 |
4 |
The manual test-writing pass added 55 tests that immediately surfaced real issues (the clippy warnings, the missing pipe-mode count support). Agents tend to write the happy-path implementation and stop.
Recommendation: Agent prompts should explicitly require tests. "Implement X" should always mean "implement X with tests for every public function." This should be part of the Crosslink rule set, not left to the human to remember.
Issue granularity needs a lightweight tier
Creating a tracked issue for a 1-line clippy fix adds overhead that doesn't serve accountability — it creates noise that obscures the real issues. The current system has one granularity level: a full tracked issue with priority and labels.
Recommendation: Add a crosslink patch "description" command that auto-opens and auto-closes on commit. This preserves the audit trail for minor fixes without the friction of full issue management.
By the numbers
| Metric |
Value |
| Crates |
4 + xtask |
| Total tests |
273 |
| Clippy warnings |
0 (with -D warnings) |
| Lines of Rust |
~3,500 |
| Parallel agent waves |
2 (wave 1 failed, wave 2 succeeded) |
| Bugs caught by smoke test |
3 (pipe count, pipe line-range, JSON glob) |
| Bugs caught by Windows CI |
3 (path escaping, lock handles, JSON paths) |
| Crosslink issues created |
12 |
| Commits on PR branch |
7 |
Conclusion
Crosslink's core thesis — accountable, traceable, human-supervised AI development — proved out in practice. The audit trail was clean, the human maintained control, and quality issues were caught before they reached the remote. The system is well-suited for environments where "move fast and break things" is not an option.
The gaps are solvable: fix worktree hook resolution, add language-specific pre-commit gates, add a lightweight patch tier for minor fixes, and bake test requirements into agent prompts. These are engineering improvements to a sound architecture, not fundamental design flaws.
For science labs building precision software, Crosslink offers something the gastown approach cannot: the ability to explain, justify, and audit every line of code your AI agents produce.
https://github.com/dollspace-gay/ripsed
cosslink was used to build this from greeenfield to mvp in about an hour, here are claudes notes on what worked vs what didnt
Ripsed Build Retrospective
Project: Crosslink + Multi-Agent Fabrication of a Rust CLI Tool
Date: 2026-03-01
Tool under test: Crosslink (accountable AI development system)
Project built: ripsed — a fast, modern stream editor in Rust (4-crate workspace, 273 tests, full CI)
Build method: Multi-agent parallel implementation from a design document, human-supervised via Crosslink
Context
This project was built from nothing — a design document — to a working, tested, CI-enabled Rust tool in a single extended session. The goal was to evaluate Crosslink as a system for fabricating precision software, the kind of code that belongs in science labs, clinical pipelines, and instrument control — not disposable prototyping slop.
The comparison point is the "gastown" approach: yolo hundreds of agents, generate code fast, treat everything as disposable. Crosslink takes the opposite stance: every change is tracked, every session has handoff notes, the human controls all git writes, and quality gates are enforced by hooks.
What Crosslink got right
Accountability and traceability
Every change had an issue number. Every session had handoff notes. When Windows CI failures surfaced three distinct bugs (path escaping, file handle semantics, lock deletion), the fix history was clean and auditable:
Each had a focused commit with a clear message. For a lab shipping instrument firmware or processing clinical trial data, you can point an auditor at the issue trail and show exactly what changed and why. That traceability is non-negotiable for regulated environments.
Human-in-the-loop for git writes
The
work-check.pyhook blocks allgit push,git merge, and other mutation commands. The human performs all git write operations. This caught real problems:With a yolo approach, broken agents might have pushed garbage to main. Nobody would know which of the 100 agents introduced the broken lock test. Crosslink's overhead is the price of knowing what your software does and why.
Session continuity
The
crosslink session end --notes "..."/crosslink session starthandoff mechanism worked well across multiple sessions. When context was compacted or a new session started, the handoff notes provided enough state to resume without re-exploring the codebase. This is critical for multi-day projects where context windows are a real constraint.Parallel agents with crate boundaries
The wave-2 launch of 4 parallel agents (core hardening, CLI completion, FS deepening, CI/benchmarks) all completed and merged cleanly. The 4-crate workspace architecture (
ripsed-core,ripsed-fs,ripsed-json,ripsed-cli) gave natural isolation boundaries. Each agent worked on a different crate with minimal file overlap. This is the ideal case for parallel AI work: clear boundaries, shared interfaces, independent implementation.What went wrong
Worktree hooks are broken (critical)
The wave-1 agents used
--isolation worktreefor safe parallel work. All 6 hit a hook deadlock because.claude/hooks/work-check.pyusesgit rev-parse --show-toplevel, which resolves to the worktree root — not the main repo where.claude/hooks/lives.This means the primary isolation mechanism for parallel agents (worktrees) is incompatible with the primary quality mechanism (hooks). For a precision-software tool, this is a critical bug: it forces you to choose between parallelism and quality enforcement, when you need both.
Recommendation: Hooks should resolve paths relative to the main working tree, not the current worktree. Or the hook setup should be copied/symlinked into worktrees automatically.
cargo fmtshould be a pre-commit hookFormatting was never enforced automatically.
cargo fmthad to be run manually, repeatedly, and every commit needed a follow-up formatting pass. For a system selling itself on "no slop gets through," formatting should be non-negotiable and automatic.A Crosslink pre-commit hook that runs:
...would have caught formatting drift, deprecated API warnings, and clippy issues before they ever landed in a commit. This is low-hanging fruit that would significantly improve the out-of-the-box experience for Rust projects.
Recommendation: Add language-specific pre-commit quality gates to the Crosslink rule sets. For Rust:
cargo fmt --checkandcargo clippyat minimum.Cross-platform issues were invisible until CI
Three distinct Windows failures surfaced only after pushing to CI:
Path separators in JSON:
dir.path().display()producesC:\Users\...on Windows. Backslashes are JSON escape characters. Every test that embedded a path in a JSON string broke.File handle semantics: On Windows, you cannot delete a file with an open handle (
PermissionDenied). The lock file'srelease()method calledremove_filewhile theFilehandle was still open. Linux allows this silently.Both were invisible on the dev machine (Linux/WSL2). The CI matrix (Ubuntu, macOS, Windows) caught them, but only after the PR was created.
Recommendation: For projects targeting multiple platforms, the design document should include a "Platform Considerations" section. Cross-platform gotchas (path separators, file handle semantics, line endings) should be called out explicitly so agents can handle them from the start.
Agents don't write enough tests
Every agent-written module had test gaps. Five source files shipped with zero unit tests:
operation.rsconfig.rserror.rsresponse.rsschema.rsThe manual test-writing pass added 55 tests that immediately surfaced real issues (the clippy warnings, the missing pipe-mode count support). Agents tend to write the happy-path implementation and stop.
Recommendation: Agent prompts should explicitly require tests. "Implement X" should always mean "implement X with tests for every public function." This should be part of the Crosslink rule set, not left to the human to remember.
Issue granularity needs a lightweight tier
Creating a tracked issue for a 1-line clippy fix adds overhead that doesn't serve accountability — it creates noise that obscures the real issues. The current system has one granularity level: a full tracked issue with priority and labels.
Recommendation: Add a
crosslink patch "description"command that auto-opens and auto-closes on commit. This preserves the audit trail for minor fixes without the friction of full issue management.By the numbers
-D warnings)Conclusion
Crosslink's core thesis — accountable, traceable, human-supervised AI development — proved out in practice. The audit trail was clean, the human maintained control, and quality issues were caught before they reached the remote. The system is well-suited for environments where "move fast and break things" is not an option.
The gaps are solvable: fix worktree hook resolution, add language-specific pre-commit gates, add a lightweight patch tier for minor fixes, and bake test requirements into agent prompts. These are engineering improvements to a sound architecture, not fundamental design flaws.
For science labs building precision software, Crosslink offers something the gastown approach cannot: the ability to explain, justify, and audit every line of code your AI agents produce.