How I Work
I'm not the kind of consultant who hands you a PDF and disappears. I work through GitHub, asynchronously, embedded in your actual development flow. My approach is informed by 16 years of generative AI research and a background in electroacoustic composition — a discipline built on trained perception.
Not a checklist. A way of seeing code.
My methodology is informed by my artistic training in electroacoustic composition — a discipline where you train your perception to separate signal from source. I apply that same training to Rails codebases: reading beyond the surface to see structure, entropy, and the decisions that will hold or break under pressure.
Reduced Reading
In electroacoustic composition, "reduced listening" means stripping everyday sounds to their essence — hearing what’s actually there, not what you expect to hear. I apply the same discipline to code: separating what it does from how resilient it is. Same codebase, multiple lenses.
Entropy Assessment
Every codebase drifts toward disorder. The first question isn’t "what’s broken?" — it’s "where is entropy winning?" What coupling, duplication, and hidden complexity is silently compounding?
Signal over Noise
"Only record what you want to hear." I evaluate your domain model and architecture before looking at libraries and patterns. A clean foundation matters more than clever layers on top.
Strategic Sacrifice
Like a chess gambit — accepting temporary complexity for long-term positional advantage. Not every refactor needs to happen today. But the plan for it does.
First Principles
When something is unclear, strip it back to basics. Understand what the framework actually does before adding abstraction. Working within constraints produces the deepest understanding.
Four phases — from first read to steady state
Assessment
I read your codebase cold — the way a composer approaches arrangement: first the whole structure, then the individual voices, then how they relate. I look for the typical orientation marks: tests (are there any?), architecture, conventions. In AI-generated codebases, most of those marks are missing.
Diagnosis
Where is entropy winning? What’s the domain model quality (signal)? What’s been layered on top (noise)? Where has AI generated plausible-but-wrong patterns? I distinguish configuration issues from architectural problems — and framework built-ins from reinvented wheels.
Strategy
Sometimes the answer is "migrate." Sometimes it’s "refactor." Sometimes it’s "this is fine, keep going." I’ll be honest about what you need — even if it means less work for me. The goal is to make you more self-sufficient, not dependent.
Ongoing
For retainer clients: async PR reviews through GitHub, architecture guidance on every major decision, and optional sync deep-work blocks when the async loop feels too slow. Your CTO is watching — every week, not once a quarter.
Code Sculpture
A seven-part essay series on art, software craft, and what AI cannot understand about code. Each essay maps a concept from my artistic practice to a principle I apply in every review.
An Artist’s Lens on Software Development
Trained perception — what reduced listening teaches you about reading code
02Entropy, or Why the Pile Keeps Growing
Why every codebase drifts toward disorder — and what to do about it
03The Crumbling Codebase
Technical debt as physical decay — and the energy required to reverse it
04The Practice
Embodied mastery vs. pattern-matching — AI as collaborator, not replacement
05Gambit
Strategic sacrifice — accepting complexity now for positional advantage later
06Only Record What You Want to Hear
Signal over noise — why the domain model matters more than the library layer
07First Principles
Constraints as understanding — why working within limits produces the deepest insight
AI writes code that looks senior. It isn't.
After dozens of Rails codebases — including AI-generated ones — I know where the patterns break. Most of what I find aren't bugs. They're structural decisions that compound silently until something fails under real load.
Ruby is the best language for AI-assisted development — but conventions only protect you if someone knows what they are.
From dozens of reviews
- Rails convention violations that AI doesn’t know are violations
- Configuration issues misdiagnosed by AI as requiring platform changes
- Architecture decisions that create predictable scaling problems
- Junior-developer-level mistakes produced by AI that looks senior
- Reinvented wheels — code that duplicates what the framework already provides
- The gap between "it works" and "it will hold"
This isn't typical consulting
| Typical consultant | How I work |
|---|---|
| Checklist-driven audit | Perception-driven: multiple lenses on the same code |
| "Here’s what’s wrong" | "Here’s where entropy is winning and the strategic moves to reverse it" |
| Feature-by-feature review | Foundation first: domain model, architecture, then layers |
| Prescriptive — "do this" | Strategic — "here’s the gambit: accept this complexity now for this advantage later" |
| No AI perspective | Knows how AI generates code and where it systematically fails |
You ship. I review. Nothing goes to production unchecked.
This is how retainer clients work with me day to day. Everything happens through GitHub — no scheduling, no meetings unless you want them.
Spec out the desired behavior in a GitHub issue
Arrive at consensus — then move to “ready”
Your AI agent creates a branch, writes a system test, opens a PR, links to the issue
I review the PR
Iterate until the test (and all tests) pass
We decide together when to merge — only then is the work finished
Need to move faster? Optional 3-hour sync deep-work blocks collapse the loop when the async cycle feels too slow for a particular architectural shift.
Two ways to work together
Most clients start with an audit. If we're a good fit, the retainer is how I stay in the room.
Codebase Review
From €3,000
A deep audit of your codebase — architecture, security, performance, and the AI-generated patterns that will bite you later. You get a prioritized report: what to fix now, what can wait, and what's actually fine.
- Architecture & domain model quality
- Security vulnerabilities & auth hardening
- Performance bottlenecks & N+1 queries
- AI-generated anti-patterns
- Test coverage gaps
- Deployment & infrastructure risks
- Clear, prioritized action plan
Final price based on codebase size. Free 30-minute intro call to scope the work.
CTO Retainer
€5,000/mo
20 hours/month
A senior technical partner in the room — every week, not once a quarter. I build the workflows, review the PRs, and set up the conventions that let you and your AI make real, dependable progress.
- Async PR reviews through GitHub
- Architecture guidance on every major decision
- AI workflow setup — conventions your agents follow
- Security & performance oversight, continuously
- Optional sync deep-work blocks
- Direct access — no ticketing, no account managers
No long-term commitment. Cancel anytime.
Find out where you stand.
A 30-minute intro call to understand your codebase and see if we're a good fit. No pitch, no pressure.