I build backend systems and developer tools, and prove they work.

FaultLine spawns its bundled shop service, probes POST /api/orders and GET /health every 0.4 s, injects the fault for 6 s, then grades three hypotheses on the orders probe: steady state before the fault, behavior during it, and recovery after. The last run of each choice is saved and shown on load; one experiment runs at a time, so if someone else is running one you will watch theirs.

The diff is direction-aware: a new required field breaks clients that send requests but not clients that read responses, and a removed field is the reverse. Schemas used both ways get the stricter verdict. Validation runs the project's own contract enforcer, which converts the operation's response schema to JSON Schema and reports field-level drift.

The demo server keeps no language model loaded, so it runs CodeRAG's offline mode: BM25 retrieval over each function's name, docstring and code, then an extractive answer built only from sentences in the retrieved code. When the best passage scores below 0.20 it refuses instead of citing weak matches. With a local model, the same pipeline embeds chunks with nomic-embed-text and writes the answer with an LLM.

The rules are line-based regular expressions, each paired with a suppression for its most common safe look-alike (parameterized queries, escaped templates, environment lookups). Every line of the sample app that matters is labeled in expected.json, so precision and recall are measured, not claimed. The one miss is deliberate: SQL built across two lines needs taint analysis, which line rules cannot do.

The report loads 1,000 orders, counts VIP customers and totals revenue for each day of the year. Each step has a classic slowdown and its fix: N+1 queries versus one JOIN, list versus set membership, and a scan per day versus one pass. SQLite runs in the same process, so each query also sleeps 0.1 ms to model a database round trip; that is why N+1 shows up as waiting, not CPU. Numbers are measured on this server for each run.

Supports G0/G1, XY arcs with I/J or R, G20/G21, G90/G91 and drilling cycles (G81–G89, drawn as holes). Codes that do not change the XY path, such as tool changes and spindle commands, are listed as notes; codes the preview cannot model, such as G28 and cutter compensation, are listed as warnings. Distances include Z moves; the plot shows XY. This previews geometry; it does not verify a program for a machine.

Accepts LINE, LWPOLYLINE (including bulges), ARC and CIRCLE on the XY plane in millimetre or unitless drawings, up to 100 entities and 500 KB. Curves are cut as chords of at most 2°. Cycle time assumes the programmed feed and 5,000 mm/min rapids. The program has no tool changes or cutter compensation; check tooling and controller setup before machining.

Each contour keeps its direction and start vertex; only the visiting order changes. 2-opt starts from the nearest-neighbor route and reverses sub-sequences while travel drops. Because a contour can end away from where it starts, each reversal is scored on the whole route with prefix sums, O(n²) per pass. Savings are XY rapid distance from the origin and exclude Z travel. The original order is kept if a heuristic would make it worse.