Projects

NoORM

A CLI for SQL-first database development. Think of it as the JavaScript equivalent of dbt, except it works across the popular relational databases: Postgres, MSSQL, MySQL, and SQLite. It manages your SQL files, tracks changes, and runs builds across dev, staging, and production. No ORM required.

The core idea: your SQL files define the schema as it is now, not an archaeology of every change you've ever made. A fresh database builds in seconds from the current state instead of replaying three years of migration history. Existing databases evolve from whatever state they're in to current. Stages handle multiple environments with different configs.

It ships with a TUI (schema explorer, SQL terminal, dynamic EJS templates for generating files with real JS, encrypted secrets), a headless mode for CI/CD, and a type-safe SDK for building your API layer out of domain classes: consumers (queries), producers (mutations), and guards (validation).

The philosophy is opinionated on purpose. Compound keys, complex constraints, proper relational modeling, inherited keys, basetype-subtypes: the full relational model that ORMs won't let you express. Currently in alpha, with database drift detection, AI-powered changesets, and secrets disambiguation in progress. Lives on GitHub under noormdev.

Atomic Claude

My Claude Code workflow, turned into a system. It's an opinionated configuration that trades narrative for signal: same accuracy, fewer tokens, faster to scan.

Claude Code's default failure mode is guessing. It hallucinates your build commands, forgets your conventions, and pads every answer with filler. Atomic Claude fixes that with a few composable pieces:

• Project signals. A Go binary scans your repo and writes context files Claude loads every session, so it knows your framework, package manager, and build commands instead of inventing them.
• A spec-to-PR workflow. Plan, implement, and diagnose through fresh-context subagents that write tests first, gate on review, and commit per green checkpoint. Close your laptop, rerun the command next week, pick up where you left off.
• Discipline skills that auto-fire. TDD enforcement, completion verification, debugging, commit messages, code review, prose editing, and doc routing trigger on natural language. No slash command needed.
• Compressed replies. A tone layer that strips the filler out of Claude's output, with intensity levels you can switch mid-session.

Built in Go, open on GitHub.

Ignatius

Data modeling as code. Author your entities, data flow diagrams, and models as files, then verify them with the ignatius CLI. It also ships with a skill, so you can point an LLM at it and have it generate data models and flow diagrams that stay consistent with your source of truth.

Diagrams-as-an-afterthought rot the moment the schema changes. Treating the model as code keeps the picture and the system in sync, which matters most on exactly the large, long-lived projects where the modeling actually pays off.

LogosDX

Focused TypeScript utilities that run anywhere: Node, Bun, Deno, Edge, browser, React Native. Zero external dependencies across the whole monorepo.

None of this is novel for novelty's sake. Most of these problems already have tools. They just weren't built the way I wanted. Observer is a good example: nobody does regex event subscriptions, and nobody gives you a way to introspect your emitters, so you end up hand-rolling middleware between emitters and subscribers just to see what's happening. Fetch was the same story. At the time there were no real fetch wrappers, and the ones that existed, Axios included, were simplistic: no in-flight deduplication, no rate limiting, no caching, nothing that persists cookies. Utils exists because I like Go-style error handling and wanted it in TypeScript. From there I kept building until I had my own ecosystem and stopped needing to go out into the world to find these pieces. The patterns are consistent across every package, so you learn them once and use them everywhere.

Eight packages:

• Observer — Typed event system with regex subscriptions (/^user:/), async iteration, priority queues with built-in retries, and component observation. Every event is type-safe and trackable, with a built-in spy, emit validators, AbortSignal cleanup, and full introspection.
• Fetch — Native fetch with the production parts filled in: retries with exponential backoff, in-flight request dedup, response caching with stale-while-revalidate, timeouts, cancellation, cookie persistence, and lifecycle events. Configure base URLs and headers once, then make type-safe requests that fail gracefully.
• Hooks — Lifecycle hooks that talk back. Unlike fire-and-forget events, callbacks can modify arguments, set results, short-circuit, or abort with errors. Priority ordering, request-scoped state, and onion-style middleware composition. The point is giving your library's users real extension points.
• Utils — Error tuples (Go-style), retry, circuit breakers, rate limiting, runtime validation, and safe data operations. The foundation everything else builds on.
• State Machine — Finite state machines with guards, async invoke, persistence, and wildcard listeners. Type-safe transitions throughout.
• Storage — One type-safe API across localStorage, async storage, and any other backing store. Pluggable drivers, scoped prefixes, and event hooks.
• DOM — Framework-free DOM manipulation: type-safe CSS, attributes, behaviors, viewport utilities, and selector caching.
• Localize — Lightweight i18n with ICU message syntax, plural rules, scoped translations, and a CLI extractor.
• React — Every package above, reused inside React the React way: context providers and hooks for Observer, Fetch, Storage, Localize, and State Machine, with full type inference and subpath imports.

AI Tools

A Claude Code plugin marketplace. Install it once, get two plugins. Both are built for corporate environments: no network requests, no shady packages, local-first storage, rule-driven behavior. The kind of thing you can show your manager without sweating.

• ai-memory gives Claude long-term project memory across sessions. It captures observations, synthesizes reusable memories, and shares one memory service across your Claude Code sessions. MCP tools for saving, searching, and organizing; a dashboard to browse and manage; /remember and /forget commands. The thing that made me build it was proper namespace isolation. I had two repos both named monorepo and the existing tools were leaking memory between them.
• auto-approve-compound-bash auto-approves compound bash commands without lowering your guard. Written in Go, it uses a real shell parser (mvdan.cc/sh/v3/syntax) for AST-based checks against your allow/deny rules. Handles compound operators, substitutions, subshells, and nested bash/sh/zsh -c calls. When it's uncertain, it falls through safely instead of guessing. Prebuilt binaries for darwin/linux on amd64/arm64.

Skills

Skills that give LLMs thorough, current information on packages that are poorly represented in mainstream training data. Works with Claude Code, Cursor, OpenCode, and other AI editors.

Covers the common (MSSQL, Postgres, Hapi, Joi) and the uncommon (HTMX, Google ZX, Hurl, CLIs), plus my own SQL Writing Guidelines (a methodology for type-safe, access-controlled SQL Server application databases), SQL Server Performance, SQL BI & Reporting, and writing MSSQL for machine learning work.

Hapi

I'm a member of the Hapi Technical Steering Committee, and an active contributor to Hapi and Joi. It's what I've run in production for years, and I still think it's the most architecturally sound Node.js framework out there: opinionated where it matters, extensible where it should be, zero external dependencies in its core. A server framework that doesn't reinvent itself every six months. A lot of my own work is downstream of its philosophy.

TypeScript

I did the Request<Ref> TypeScript work for Hapi, which was extensive. Ref is wired into everything a request touches: payload, pres, query, params, auth, plugins, and more. If you've used typed route handlers in Hapi recently, that's this work. It took the types from "technically usable" to "actually useful."

I'm also improving the TypeScript types for Joi itself. Joi is still the most powerful and performant schema validator around, but for years its TS story lagged while Zod and others grew theirs. That gap is closing.