Inspiration
Before pocket calculators, engineers, pilots and clinicians computed with nomograms: printed charts where you lay a straightedge across two known values and read the answer where it crosses a third scale. They need no battery, no screen and no software at the point of use. The technology died because drawing one by hand was slow and error-prone, not because the idea was wrong. A printed chart still works in a field office, a classroom, a clinic with unreliable power, or during a blackout. Isopleth (the name of the line you draw across a nomogram) brings the format back by making the hard part, the drawing, automatic and checked.
Category: Resurrection. The dead technology is the nomogram, or alignment chart, invented by Maurice d'Ocagne in 1884 and retired by pocket calculators in the 1970s.
What it does
You type a formula and a range for each variable, for example BSA = sqrt(height * weight / 3600). Isopleth recognises the structure of the formula, chooses a layout (parallel scales for sums and products, a Z-chart for ratios), places and labels the scales, and shows the result as an A4 sheet.
- An interactive straightedge with three handles: drag two and the third is solved, and the sheet shows how far the straightedge reading is from the exact formula.
- An accuracy certificate printed on every chart: the worst reading error caused by a stated straightedge placement error (default 0.5 mm), measured on the printed geometry over 1,681 grid points and up to 6,724 straightedge placements, with a 1.1 safety margin.
- True-scale output: SVG in millimetres and a one-page A4 PDF with a 100 mm calibration bar, so you can check your printer before you trust the chart.
- Seven built-in examples (Ohm's law, body surface area, right-triangle hypotenuse and more), keyboard control, touch drag, and a share link that restores the chart from the URL.
- An MCP server (
make_nomogram) so an AI agent can produce the same verified nomograms as a tool call.
No install, no account, no build step: it is plain ES2022 in the browser.
How we built it
The whole project was built during the submission period with Kiro (first commit 2026-11-04). Steering files hold the nomography math once; a Kiro spec turned requirements into 43 ordered tasks; a custom agent implemented the engine core and the MCP server task by task; I hand-wrote the accuracy certificate, the sheet, SVG and PDF output and the browser studio; hooks ran the suite on every save. Details are in the Kiro write-up below and in notes/kiro-usage-log.md in the repo, which lists every Kiro session with model, credits and every hand edit.
Challenges
The central risk of a nomogram is that it looks right and reads wrong. Three bugs slipped past the first green test run (an outer square root not applied in the compiled evaluator, an expression not normalised into a product of powers, and ratios never reaching the Z-chart branch). Review found them and each came back to Kiro as a regression test. Property-based testing caught two real issues: an exp(exp(x)) overflow and a flaky monotonicity property of our own test on adjacent doubles in a log scale.
Accomplishments
- 262 automated tests, all passing, including fast-check properties that the three points of a solution are collinear, run at 200 random cases each in the collinearity suites.
- An independent check outside the suite: 2,000 random readings per example, determinant at most 9.1e-12 mm squared and relative error against the formula at most 7.5e-11.
- A browser check on seven examples with no label overlaps, no console errors, and a layout that works from a 390 px phone to desktop.
What we learned
Writing the math into steering once, and pointing every spec and task back to it, was worth more than re-deriving it per prompt. Tests that gate "task done" matter more than tests that merely exist.
What's next
Curved scales and four-variable chained charts, which this round deliberately left out to keep the three supported layouts polished.
Testing instructions
No login or payment. Open https://0smallcat0.github.io/isopleth/ and pick any example, or type your own formula such as V = I * R with ranges. Drag the vermilion handles on the sheet, then download the PDF and print at 100 percent scale to check the 100 mm bar.
To run locally: clone the repo, run python -m http.server in its root and open the page; for the tests, npm install && npm test (Node 20 or newer).
Pre-existing code disclosure
None. The repository's first commit is 2026-11-04 15:23 (UTC+8), inside the submission period. The only dependency is fast-check 3.23.2 (development only, used by the tests).
Kiro write-up (How Kiro was used)
Isopleth turns a formula into a printable nomogram. The hard part is accuracy: a nomogram is only useful if a straightedge on the printed sheet gives the right answer. So the project was set up so Kiro could not call a task done until the geometry had been checked against the formula.
IDE, CLI, Web, Crew. The build ran on Kiro CLI 3.0 in headless mode: 19 sessions, 80.36 credits, using Haiku 4.5, Sonnet 4.5, Sonnet 5.5, MiniMax M2.5 and Qwen3 Coder Next. The CLI suited this project because steering, specs, hooks and the custom agent are files in the repo and everything runs from a terminal against the test suite. I did not use Web or Crew, and the usage log shows no IDE sessions.
Steering. Five files in .kiro/steering/. product.md, tech.md and structure.md are always included. nomography-math.md loads only when Kiro touches src/core/, test/ or mcp/, and holds the derivations (per-scale moduli for parallel charts, the Z-chart diagonal parameter, the collinearity determinant). testing.md is scoped to test/ and fixes how properties are written (fast-check, at least 200 runs, each property named after its requirement). Kiro's first steering draft had three formula errors; I listed them, Kiro corrected them, and later specs pointed to the file instead of re-deriving the math.
Spec-driven development, compared with vibe coding. .kiro/specs/nomogram-engine/ was generated in spec mode: EARS requirements R1 to R9, a design with module interfaces and correctness properties, and 43 ordered tasks. A review pass fixed places where the design disagreed with the steering math and added the two properties that matter most: collinearity of the three points on a line, and certificate soundness (perturb each straightedge end by up to the stated error; the reading error never exceeds the printed bound). .kiro/specs/chart-studio/ (17 tasks) specifies the browser studio. Compared with vibe coding: the steering, agent and hook sessions ran in vibe mode, and each needed my hand review straight after (the first steering draft had three formula errors; the first hook scripts ignored a bare LICENSE path and a test gate that never saw a failure). The spec session was different because its output was reviewable before any code existed. One review of the spec (10 items) caught a false y1 + y2 = y3 claim and the missing collinearity and certificate properties, so the code was written against corrected requirements and the tests mapped one to one onto them.
Hooks. Four hooks. property-tests-on-save runs the suite when files in src/core/, test/ or mcp/ are saved (101 runs). green-before-stop blocks the agent from finishing while the suite is red, at most twice per session (14 runs, blocked once). guard-protected-files refuses writes to the contest rules, the licence and the brief (227 runs). test-after-task is defined for spec task completion and did not fire (0). The effect on the workflow: every edit of the engine is checked without anyone remembering to run the tests, the one time an agent tried to stop on a red suite it was blocked and handed the failing test names, and the guard stopped any write to the rules, licence or brief. Counts are recounted from the session logs; the hook scripts have their own tests, written after review found the first guard ignored a bare LICENSE path.
Custom agent. .kiro/agents/nomographer.md implemented the engine batches: steering loaded as resources, shell limited to node, npm, git status and git diff, one task at a time, a fast-check property for every universal requirement, and a task is marked done only after npm test is green. The effect on the build: the engine batches came back in a consistent shape, with steering already loaded and a narrow shell, so review could concentrate on the math. It also did not always follow the rule: one batch ticked tasks whose files it never wrote, and I unticked them.
MCP. mcp/server.mjs is a stdio Model Context Protocol server exposing make_nomogram (formula and ranges in; chart, SVG and certificate out), registered for Kiro in .kiro/settings/mcp.json and referenced by the agent definition. The tool is covered by tests. Without it, an agent asked for a chart would have to assemble the pipeline by hand and paste the numbers; with it, a fresh stdio session asked for a Z-chart returned the chart and its self-check (3.8e-13 difference between straightedge and formula), and a bad formula came back as a structured error with the character position instead of a stack trace.
Property-based testing. fast-check properties cover collinearity, certificate soundness and evaluator agreement with the formula. They found an exp(exp(x)) overflow in a generated expression and flakiness in our own log-scale monotonicity property on adjacent doubles. To be exact about what they did not find: the three bugs listed under Challenges came from my review of each batch against the formulas, and then became regression tests.
Division of work. Kiro wrote the engine core (parser, compiler, scales, layout, reader), the MCP server and the studio's automated checks. I wrote the accuracy certificate, the sheet, SVG and PDF output and the browser studio against the chart-studio spec, and fixed the bugs recorded in notes/kiro-usage-log.md. Kiro powers were not used: the project has no runtime dependencies and no third-party service to integrate, so there was no tool for a power to wrap; the only external piece is the test library fast-check.
Built With
- css
- fast-check
- github
- html
- javascript
- kiro
- kiro-cli
- model-context-protocol
- node.js
- svg