Coding agents copy whatever your Rails app shows them, including patterns you retired years ago. Learn how to turn the current pattern into a generator, block old ones with a ratchet test, check weird code before deleting it, and write down what your team only knows by heart.
Design review questions that catch failures before code exists: what breaks, how easy it is to roll back, how far the damage spreads, and how to ask business people about consistency without hearing "make it 100% safe". Ends with a checklist you can paste into your next design doc.
Domain model metrics turn "the split feels wrong" into something you can check: how many teams one change drags in, which arrows point the wrong way, why lines of code lie inside aggregates, and why you should sketch four models before picking one.
The future of programming is not more code. It is a knowledge graph, an event log and agents you route in code, not in prompts. My opinion on which skills pay off this year, the mistakes that sink agent projects, and why a small team with legible data beats a big one.
A modular monolith in Rails buys you one thing: a checked constant dependency graph. Packwerk 3.3 and Rails engines run against a real app show where the boundary holds, where a single method argument walks straight through it, and which of your problems stay exactly as they were.
Delete first, automate last: Elon Musk's five-step algorithm applied to software. Why questioning requirements and deleting code must come before optimization, and how automating a broken process just gives you a faster version of the wrong machine.
Architecture is the set of decisions that feel permanent after six months. An honest tour of monolith, layered, modular monolith, SOA, microservices and event-driven options: what each really costs and why the modular monolith deserves more attention than it gets.
Message ordering in distributed systems does not come from a FIFO queue. What actually keeps events sane: idempotency as the real safety net, partition keys when order truly matters, optimistic locking as a version guard, and the traps of multiple consumers.
Cynefin framework in practice for engineers: classify a problem as clear, complicated, complex or chaotic before picking a process, so you know when Agile experiments beat Waterfall plans and what to do when production is down.
Technical debt is not the real enemy: cognitive load is. Why messy abstractions hurt because of what they do to your brain, how the database quietly kills flow, and how to stop chasing code cleanliness for its own sake and start delivering again.
Snapshot databases only show the current mess, not who knocked over the chair. Event sourcing explained through an investigation lens: anatomy of an event, state recreation as time travel, why audit tables are a dead end, and the honest cost of eventual consistency.
Zanzibar is how Google authorises billions of shared resources across Drive, YouTube and Calendar. A look at its relationship-based data model, the new enemy problem that forces strict consistency, and the Leopard system that keeps checks fast.
Ruby modules often beat classes for service objects: why a shell class like PasswordResetInitiator is procedural code in disguise, using a module as a toolbox, mixins instead of artificial inheritance, and Data objects for tidy parameters.
Microservices promise independence and deliver network calls where method calls used to be. Why small and medium teams pay the highest price: chaos scaling instead of product scaling, lost shared context, operational overhead, and the way back to sanity.
Event sourcing meets GDPR the moment a user asks to be forgotten and your log is append-only. Crypto-shredding is the elegant answer: encrypt personal data per user, delete the key, and design system boundaries so backups and read models forget too.
Business archetypes prove your 'unique' domain is usually a store selling something unusual. Map complex requirements onto universal building blocks: product catalogue, orders, entitlements, inventory for services, party and billing, and stop reinventing the wheel.
Pseudo-modularity looks like clean folders and rots underneath: a change in Products breaks Inventory tests and blocks three teams. Why noun-driven modules and a shared database create facade modularity, and what real module boundaries look like.
Party archetype fixes the 120-column User god object: model people and companies as parties, roles as context instead of identity, and relationships as first-class entities, so a customer who becomes a B2B partner no longer needs an is_partner flag and prayer.
A distributed monolith is what you get when microservice boundaries are drawn wrong. How to design autonomous modules in three phases: business analysis for boundaries, tight communication contracts, and deployment decisions driven by real architectural drivers.
Module boundaries should come from simulation, not subdomain divination. An engineering method for DDD: optimise for modifiability, simulate realistic changes against candidate boundaries, prove the split with stable contracts, and explain it to the business.
Event-driven architecture with Kafka can still be a distributed monolith. The anti-patterns that get you there: CRUD sourcing, property sourcing, clickbait events, missing commands, and the fixes: rich events, outbox, internal vs external events, anti-corruption layers.
Not all events are equal: domain events, Event Carried State Transfer, notification events and the Claim Check pattern each serve a different job. A typology of what you are really sending, plus the event vs command distinction that prevents architectural chaos.
Messaging is not a default answer. When a business flow is synchronous, queues add complexity without value and message ordering becomes your biggest pitfall. How to recognise the cases where a simple synchronous call keeps the system easier to build and debug.