Engineering for Resilience, Scale & Agentic Speed.
Pragmatic architectures designed for the modern era. Specializing in codebase layouts optimized for autonomous AI developer agents, modular Go monoliths, and PostgreSQL event sourcing.
The "Boring" Architecture
I believe a system's true strength lies in simplicity, autonomy, and adaptability. In the era of AI engineering agents, premature microservices and distributed complexity introduce crippling context noise, ballooning LLM token costs and causing endless debugging loops.
My approach focuses on clean, high-performance modular monoliths in Go and PostgreSQL, architected with uncompromising domain boundaries and deterministic tools. By eliminating unnecessary moving parts, systems remain cost-effective and rock-solid for human teams—and effortlessly navigable for AI developer agents.
Expertise
Pragmatic engineering designed for developer velocity, autonomous agents, and lean operational costs.
Agentic Architecture
Architecting codebases specifically for autonomous AI coding agents. Enforcing strict layer isolation and bounded contexts. Eliminates context pollution and hallucinated cross-file edits, allowing fast, cost-effective flash-tier LLMs to deliver features with pinpoint accuracy and minimal token burn.
Modular Monoliths
Avoiding the hidden tax of premature microservices. Designing clean internal domain boundaries inside a single, highly concurrent Go deployment. Delivers high developer velocity, simple testing, and single-binary deployment economics—keeping infrastructure lean and operations minimal while preserving clean module contracts.
Event Sourcing & CQRS
Basing Event Sourcing on PostgreSQL for its battle-tested, "boring" reliability and strict ACID transactional guarantees. As the author of eventsalsa, I design Event Sourcing and CQRS architectures where state transitions are safely appended, read models stay performant and decoupled, and transactional integrity is guaranteed at the database layer.
Projects
A selection of open-source tools and libraries I build and maintain.
eventsalsa
A component-based event sourcing stack built in Go on PostgreSQL (pgx). It is simple, idiomatic Go that doesn't creep into your domain implementation—yet remains powerful, decoupled, and flexible.
go-refactor-mcp
A production-grade, stateless Model Context Protocol (MCP) server that empowers LLM agents with deterministic Go AST refactoring. Eliminates hallucinated search-and-replace edits and repetitive build → fail → fix debug loops by updating imports, package clauses, and cross-package references workspace-wide.
- check Deterministic AST symbol renaming across the entire module
- check Safe file & package moves with auto-rewritten imports and cycle detection
- check Automatic interface implementation method stub generation
ghspector
A sleek, terminal-native developer dashboard (TUI) for universal GitHub operations built in Go with Bubble Tea. Aggregates multi-repo GitHub Actions workflows, live log streaming, and keyboard-driven pull request management into a single real-time terminal interface—eliminating dozens of open browser tabs.
- check Aggregated CI/CD workflows and PRs across user and organization scopes
- check Real-time polling, attempt history cycling, and interactive log tailing
- check Keyboard-driven PR inspection, check statuses, merging, and closing
Rumil
A self-hosted GitHub App that reviews pull requests with agentic precision. It reads incoming changes, posts focused reviews with inline comments, and continuously records engineering rules and team conventions into memory (pgvector)—ensuring deliberate architectural decisions are never re-flagged as mistakes.
YouTube
I run a YouTube channel on topics of software architecture, modular systems, and building resilient engineering in Go.
TheBoringArchitect
In this channel, I share stories about software architecture in the era of AI developer agents—drawing on real experience with modular monoliths, domain modeling, and event sourcing. The takes are opinionated, but each one is backed by concrete argumentation and a transparent discussion of the trade-offs.
Videos
Domain Model Enablement
Moving beyond anemic data structs. How to model real business invariants and behaviors directly within the Go domain core without framework leaks.
Intents, Facts, Policies, Boundaries
The four foundational primitives of pragmatic system architecture. Dissecting commands (intents), immutable events (facts), rules (policies), and context edges.
Real context isolation reaches the database
Context boundaries mean nothing if every service joins over a global database schema. Enforcing schema boundaries and transaction ownership all the way down to PostgreSQL.