Gauge

Merge requests and CI for knitting patterns. A robot test-knits every row of every size in software and fails at the exact row where the stitch math breaks — before anyone wastes yarn.

Comment

Inspiration

Knitting patterns are software that humans execute. They're numbered rows of instructions, they ship with bugs, and the bugs are so routine that publishers maintain public errata pages to correct stitch counts after the fact. The community even runs its own review process before a pattern is released — test knitting: volunteers knit the unpublished pattern and report problems back over email threads and spreadsheets, paying for the privilege with their own yarn. The craft already has a word for revert (tinking — un-knitting one stitch at a time).

A ritual that is already code review, run on infrastructure that is already worse than what software engineers had in 2005, deserved the real tool.

What it does

A designer pastes a written pattern. A Gemini agent parses it into structured rows and sizes — it asks plain-language questions about anything ambiguous; it flags, it never guesses — then, through GitLab's MCP server, creates a real GitLab project, commits the pattern source, and wires up CI.

The pipeline is a deterministic checker — plain math, no AI — that test-knits the pattern in software: it walks every row, for every size, tracking stitch counts through increases, decreases and repeats, validating repeat divisibility and the pattern's own "you should have N sts" claims. It fails with the exact row: Size M, Row 47: 124 sts → 128 sts — breaks the 8-st lace repeat. Red is math, never opinion.

From there the pattern lives like software, translated into knitting language by the agent:

  • A revision is a merge request — the diff reads as knitting, CI re-knits all sizes, and the merge button stays human (merging over a red check requires typing the breaking row number yourself).
  • Test-knitter feedback, typed at a phone-friendly share link with no account, is filed as row-pinned issues.
  • Merged fixes regenerate the pattern's public errata page — the page publishers maintain by hand today.
  • Published versions are tagged releases; all sizes green earns the pattern a badge for its listing.
  • The fabric itself is rendered: a simulated swatch knits row by row, and when the math breaks you see the failure in the fabric at the failing row.

The GitLab project is the database. Pattern history, MRs, issues, releases, errata, badge — all of it is ordinary GitLab objects the designer can clone, export, or delete with ordinary GitLab means. The server stores nothing about the user.

How we built it

  • core/ — a dependency-free notation parser, stitch-count checker and canvas fabric renderer that run identically in Node, the browser, and GitLab CI (the same checker is bundled into tools/check.cjs and committed into every created pattern project, so the verdict you see is the verdict CI computes).
  • server/ — Express. Gemini on Vertex AI is the agent's language: parsing patterns, translating diffs and verdicts into knitting sentences, drafting MR descriptions and release notes. The GitLab MCP server is the agent's hands: create project, commit, open MRs, file issues, read pipelines — every receipt in the UI links the real GitLab object.
  • web/ — eight static screens, no framework, no build step. Wool paper, charcoal ink, the community's chart symbols as the only icon set.
  • Deployed on Cloud Run; stateless by design.

Challenges

  • Knitting notation is a folk language. Per-size parentheses, bracketed per-size groups, "rep from * to last 5 sts" — the deterministic checker had to parse all of it without ever guessing. Anything it can't read is reported as a skipped row, never silently passed.
  • GitLab's MCP server is Beta. The app speaks to the hosted endpoint and falls back to a bundled stdio MCP server with the same token; failed calls surface their raw reason with a retry that re-runs only that call.
  • New GitLab.com accounts can't run shared runners until identity verification. Pipelines are still created and linked as real objects; until the account is verified, Gauge runs the same bundled checker server-side for the verdict — identical math, same code CI executes — and says so honestly in the README.

Accomplishments

The one we care about: the demo pattern's shipped bug class — a stitch count that silently breaks after an increase row — is caught at the exact row, across nine sizes, in seconds, by a pipeline a knitter never has to understand. And the merge button is still a human's.

What we learned

"One application" is load-bearing for this audience in a way it never is for developers. A knitter operates one login and one tab: repo, review, checks, feedback, errata and version history in a single place. Delete GitLab from this product and what remains is a text parser.

What's next

Chart-image parsing (refused honestly in v1), more constructions (brioche, complex colorwork are currently skipped-not-guessed), and compiled PDF releases.

Built With

Share this project:

Updates