Stitchproof

A compiler for knitting patterns: AI reads the words, code counts every stitch in every size, finds the errata and suggests the fix, before you cast on.

Comment

Inspiration

On October 22, 2026, Etsy banned AI-generated knitting, crochet and other craft patterns, after admitting that many buyers can't tell which items involve AI (CNBC). A knitwear designer told CBC her sales had halved since those patterns appeared. And even careful shops ship count errors: Purl Soho's free Classic Ribbed Hat once said 18 stitches remained where the arithmetic left 12, and a knitter only found out mid-crown (2019 comment thread).

Every written pattern makes a promise: follow these steps and you'll have this many stitches. Checking that promise is arithmetic, not judgment. So we built the checker.

What it does

Stitchproof is a compiler for knitting patterns. Paste a pattern and it:

  • Proofs every row in every size against the count the pattern states: repeats that don't fit, stitches that run out or are left over, wrong totals.
  • Reads patterns the way they're published: stitch markers ("k to 2 sts before m, k2tog, sm"), repeat counts that differ by size ("3 (4, 5) more times", "– (1, 2)"), "Adult sizes only" sections, and "rep last 2 rnds until 16 sts rem", which it works out and checks lands exactly.
  • Finds root causes, not a wall of red. One bad cast-on is one erratum, with "21 later rows go wrong because of this one".
  • Suggests the fix, with evidence. It tries small edits, re-counts the whole pattern for each, and applies the winner in one click. Sometimes the printed count is the typo, and it says so.
  • Reads messy prose with AI. Gemini (with OpenRouter as a fallback) rewrites loose instructions into strict notation, copying every number (even wrong ones); the parser re-checks that translation before anything is counted.
  • Opens PDFs on your device. Most patterns arrive as PDFs; Stitchproof reads the text in the browser (nothing is uploaded) and joins rows that wrap onto the next line.
  • Helps you knit and share. Knit mode (one row at a time, in plain English), private share links, and a report you can copy or download with the exact rows, for the seller, a marketplace report or test knitters.

Try it: open the live site and click Try the flawed beanie (three planted errata across three sizes), or the Weekend Scarf sample for the AI reader.

Who it's for

Designers and tech editors who re-count every size by hand before publishing; knitters, especially beginners, who want to know a pattern works before buying yarn; and buyers who need evidence, not a hunch, when a pattern can't be knit.

Not another row counter. Row-counter apps keep your place but trust the pattern's numbers. Stitch calculators space increases for one row you type in. Tech editors check every size by hand. General chatbots read prose well but don't keep a running stitch total. Stitchproof checks that the whole pattern adds up, in every size.

Tested on real patterns

We pasted eight free hat patterns from Purl Soho exactly as published: 38 sizes, with stitch markers, sizes-only sections and per-size repeat counts. Stitchproof read every line offline, with no AI. Seven add up in every size. In the Box Hat, the largest size says "repeat last two rounds 12 more times", which asks for a 13th decrease round when only 1 stitch is left where it needs 2; 11 more times reaches the stated 36 stitches. Stitchproof flags it and suggests exactly that fix. We checked it by hand. The full table, with links, is in the README.

Then we asked Gemini for a three-size hat pattern to sell and pasted its answer unchanged. The 3.5 Flash-Lite model's pattern says to repeat "K2, P2 times", and its last round "decreases 12" but really decreases 18; Stitchproof flagged both, live, with AI reading the prose and code doing the counting. The 3.1 Pro model's hat added up in every size, and it exposed a bug of ours (a dash in a stated count read as zero), now fixed with a test.

How we built it

Planned with the Devpost Learn Skill Pack (1-start → 6-ship); the scope, PRD, spec and build checklist are in the repo's devpost/ folder. Next.js 16, React 19, TypeScript, Tailwind 4, and the AI SDK with Google Gemini (gemini-flash-lite-latest, reasoning off) and OpenRouter.

The core is one table: every stitch uses some stitches and makes some (k2tog uses 2, makes 1; yo uses 0, makes 1). A hand-written parser turns notation into a stitch program, a counter walks every row for every size (carrying marker positions from row to row, and turning them around on flat rows), and a fixer searches single-number edits. Standard patterns never leave the browser; only lines the parser can't read go to the AI route (Zod validation, size and rate limits, timeouts, a same-origin Content-Security-Policy).

Measured, not claimed: we broke six correct patterns 450 ways (every number ±1 and ±2). Stitchproof caught all 423 typos that change a stitch count, repaired all 423, and restored 89.4% to the designer's exact text. 92 unit tests and 34 end-to-end runs (desktop and mobile, with axe accessibility checks) gate every change.

Challenges we ran into

  • Causes vs. symptoms: apply the best fix, re-proof, and see which rows recover; those were knock-on errors.
  • Which number is wrong: if every later row works from the instructions' count, the printed number is the typo; if they expect the printed number, the instructions are wrong.
  • Markers and sizes: "k to 2 sts before m" has no fixed length, so the counter has to know where every marker sits, and a block repeated "2 (3, 4) more times" is a different number of rows in each size.
  • Keeping the AI honest: a model that "helpfully" corrects a pattern hides the very errors we're looking for, so it must copy, and the parser must accept its output.

What we learned

  • Plan before you build. Writing the scope and PRD first made "proof, don't generate" the core decision.
  • Give AI an inspectable job. Asking for notation we can parse, not hidden JSON, means one parser checks both paths.
  • Measure, don't claim. Breaking patterns on purpose exposed a real parser bug that our samples never hit.

What's next

Testing with knitters outside our team (nobody else has tried it yet; we'd like 2–3 designers to run their own patterns through it), crochet, and chart images, with the same rule: AI reads, code counts.

Team

  • Adeel Falak Sher (product lead): delegated the idea search and the build to Claude under the Skill Pack, reviewed the live app, ran three judge-style audits and decided which findings to fix, set up deployment and the AI keys, and published the demo and this submission.
  • Raouf Khalid (research and testing): researched how published patterns are written (markers, per-size counts) and the errors knitters report, tested the samples and Knit mode, and reviewed the write-up.

Built with AI

Built with Claude (Anthropic) as a coding assistant, following the Devpost Learn Skill Pack: Claude wrote the code and drafted the planning docs, demo video and this write-up under our direction. The sample patterns are original. The demo video was recorded from the production build; its AI step replays a real Gemini response captured from the live site.

Built With

Share this project:

Updates

Submission history