Consulting · Open source · Research
We ship production code with AI, inside engineering guardrails that make most wrong versions impossible to build — so the speed compounds, while the breakage doesn't.
01 — Positioning
You're a fit if you run a platform team using a typed language (C++, Rust, Scala, TypeScript) — typically Series B–D, 20–80 engineers — with a regression you can name, an improvement plan you've already postponed twice, and a real interest in letting LLMs accelerate the work without quietly eroding what types guarantee.
02 — Services
Constructive Programming partners with teams on codebases that have accumulated the usual debts of growth — typed boundaries treated as untyped, required fields treated as optional, 800-line objects nobody dares touch. A single thread runs through every engagement: narrowing. Shrinking the set of values a type can hold so that fewer wrong programs compile, so thousands of lines go red and can be safely deleted.
What is different about our practice: we ship production code paired with LLMs. Narrow types and machine-checked properties are the strictest guardrails an agent can operate against — they turn non-deterministic output into a verifiable artefact.
Advisory
Design review through a cardinality lens; narrowing type signatures; identifying where capability-based abstractions, refinement types, or algebraic effects unlock simpler code.
→ A written, defensible improvement plan — with effort estimates — before you spend two quarters on the wrong one.
Architecture reviewDelivery
Embedded in your team to ship typed-FP features in Scala or Rust, with the same constructive discipline applied to PRs as to architecture.
→ Senior delivery hands in your repo within weeks — and a team the discipline rubs off on.
Embedded ICAI
Building the deterministic harness around your codebase — linters, types, properties, eval suites — so the non-deterministic behaviour of agents becomes a self-correcting development session.
→ Your team moves faster with LLMs, and can trust the output.
Fractional advisoryEnablement
Distilled from a decade of constructive-programming workshops, tailored to your stack and your team's seniority mix.
→ The practice stays after we leave.
All engagements03 — Process
01
A 30-minute scoping call — free, and honest about fit and start dates. You describe the problem; we work out together which offering fits. A written one-page scope follows within 48 hours.
02
Architecture review through a cardinality lens: observed structure, the strongest risks, and three to five concrete narrowing moves with effort estimates.
03
Pull requests, design docs, and eval suites — shipped under your repo and your release cadence, paired with LLMs against deterministic harnesses.
04
Machine-checked before it merges: types, properties, and evals green. Pair sessions on demand so your team owns what ships.
05
Monthly written summaries for stakeholders, a hiring rubric, team rituals — the constructive discipline stays after we leave.
If the readout doesn't surface at least one narrowing move worth more than the fee, we refund half. The report is yours to keep regardless.
04 — Recent outcomes
Otravo · Travel e-commerce
A core pipeline ran for eleven hours — too slow to rerun, too central to ignore. Rebuilt with optics and a narrowed data model.
Eleven hours to fifteen minutes.
Bodireel · Consumer product
A consumer-facing system that had to stay fast and stay up while the infrastructure bill came down — performance and cost treated as design inputs.
P95 under 20ms, 100% uptime, 30% less infra.
Royal Philips · Health technology
Static analysis grounded in Total Program Cardinality — counting the inhabitants of a program's types to keep quality measurable as the codebase grows.
A code-quality metric the compiler can enforce.
05 — Engineering depth
The harness we build around every codebase — each layer narrows what the one above it can get wrong.
agentsnon-deterministic, self-correctingeval suitesbehaviour pinned downstatic analysiswhole-program guaranteespropertieslaws, machine-checkeddomain typesillegal states unrepresentable06 — Research & open source
Existential optics for Scala 3, built on cats.
One Optic[S, T, A, B, F] trait unifies Lens, Prism, Optional, Traversal, Grate, AlgLens and Kaleidoscope. Discipline-checked laws, scoverage-driven quality, JMH benchmarks against Monocle, and circe + avro integrations with an observable-by-default Ior failure surface.
Counting type inhabitants — keep your types small.
A type-cardinality calculator for Scala ADTs (|T| over +, *, ^), plus a scalafix rule that flags sum types used as function arguments. Backs the "Keep Your Types Small" argument with code.
Fixed — a new functional language
Program against capabilities, not data structures. Fixed
pushes algebraic effects, Perceus reference counting, and
functional-but-in-place updates up to a capabilities level:
you describe what your methods need (cap), the
compiler picks the data structures and machine layout.
Properties (prop) live alongside the capabilities
they govern; refinement types are first-class. Phase 0 —
design — with eleven example programs exercising the language.
07 — Writing
How functional programmers actually approach software architecture — under the misconceptions.
A new code-quality metric grounded in counting the inhabitants of a program's types.
The reification fallacy and the problematic abstractions it produces.
Practical dependent typing in mainstream languages, without a specialised compiler.
Available for select engagements
Engagements range from a focused two-week review to a multi-month embedded role. Based in the Netherlands; comfortable with EU MSAs and standard NDAs. The scoping call is free — and honest about fit.