Article Constellation

What GitHub's Spec Kit is, why it feels heavy for a small feature, and a four-file preset that turns it into one page and two commands, with a sample constitution and a short step-by-step guide.

Producing code got cheap. Deciding that code is correct did not, and that decision is now the job. What changed, which qualities now pay, and what the hiring data says about who companies actually want.

One team says a router cut their bill 60%. Another says it fixed their uptime. A third says it lets them swap models in a config file. All three are true, and all three are different systems. Notes from my research into LLM cost and token optimization: what routing actually decides, which of the three decisions holds the savings, and when not to use a router at all.

On 28 July 2026 the MCP spec removed its session handshake and went stateless. We made the same change to REST services ten years ago. The agent stack is not a new kind of system. It is two old architecture styles rebuilt with new parts, plus three things that have no ancestor at all.

SOLID was written for a human holding seven things in working memory. The agentic era has replaced that reader with agent holding a context window, and the rules got more binding, not less. What each principle became in the agent era, what genuinely aged, the one question still open, and the original 2014 article below, unchanged.

Models are commoditizing, so the moat moves to what can't be downloaded: a map of eight differentiators governed data, accumulated memory, harness engineering, evals, workflow surface, ecosystem, provable trust, and the flywheel that compounds them all standing on one foundation: governance enforced at runtime, not in a PDF.

Part 2 of 2. Defending MCP against semantic attacks, identity & token handling, observability with token-cost + audit-origin, governance via the registry, and testing with evals.

Part 1 of 2. The mental model, DDD-aligned MCP architecture, and intent-shaped tool design for production MCP Understanding MCP with REST analogy

The 'use-everything' RAG stack is the most expensive mistake you can make. A stage-by-stage field guide chunking, retrieval, fusion, reranking, recall tools, bounded reasoning, and ops with the decision rules I use in production.

Most people are still rolling the dice with LLMs. TACORE Task, Audience, Context, Output, Rules, Examples & Evaluation is the framework I use to architect intent and get production-ready output on the first run.

Technical people lose the room by leading with how, instead of why it matters. Translate tech into business value, lead with results, and tell a story they care about.

From single-shot GenAI to autonomous, tool-using, multi-step Agentic systems the architecture shift every enterprise needs to plan for.

Practical patterns for working with semi-structured JSON at petabyte scale in BigQuery.

Under-the-hood mechanics, optimization patterns, and the real-world nuances of Google Firestore at scale.

How agentic AI is reshaping the software development lifecycle from requirements to deployment.

Field notes from GCP Next 2025 Gemini 2.5, Vertex AI Agents, Agentspace, and the agentic infrastructure stack.

A 7-step decision framework for technical leaders in the AI era pre-mortems, bias defenses, and 'one-way door' thinking.

The realities, traps, and patterns nobody tells you about Cassandra CDC and bulk export in production.

Production-grade CDC and migration patterns for PostgreSQL logical replication, Debezium, and the operational realities.

Separation of storage and compute, columnar tricks, and SQL patterns that keep BigQuery fast and your bill sane.

How Firestore actually works the document model, why every query is indexed, the life of a write through Paxos, and why data modeling is cost modeling.

A security policy can't be written until you know what you're protecting and from what. The risk-assessment-first approach, the eight-step policy process, the incident response plan, and the threat taxonomy plus how it all translates to modern software engineering and public cloud: threat modeling, policy-as-code, SEV levels, and the shared-responsibility model.

Beam's promise is one pipeline model, any language, any runner. The same Elasticsearch-to-Firestore ETL in Go, Java, and Python: what stays identical, and where the SDKs differ.

Two things that sound impossible until you see the trick horizontally-scalable SQL with strong global consistency, and infrastructure you describe instead of build.

Both cut the bytes BigQuery scans and your bill but in different ways. When to prune whole partitions, when to sort into clustered blocks, and when to do both.

Semi-structured JSON meets a relational warehouse the impedance mismatch. Five ways to model it, the resilience-vs-performance trade each makes, and how to choose.

Most workplace conflict is about interests, not personalities, which means it's solvable with a process. The six steps, and how to apply them across teams that don't report to you.

Cloud migration is a business decision gated on a CBA, not a tech project. Run the numbers (TCO vs cloud), weigh the risks, then execute across a lifecycle and know how the value differs by company size.

Event-driven systems are async by nature, but some flows need a fast, accurate, synchronous answer. You don't abandon EDA. You carve a synchronous fast-path for the few cases that need it.

EDA replaces direct calls with an exchange of facts. The loose coupling buys resilience and agility and bills you in eventual consistency and debuggability. The patterns, the trade-offs, and CQRS.

A cache is only as good as the pattern that keeps it in sync with your source of truth. Cache-aside, read-through, write-through, and write-behind the trade-offs each one makes.

Why NoSQL modeling is the inverse of relational you design around your queries, not your entities and how partition keys, sort keys, and indexes make it work.

A well-defined problem leads to breakthrough solutions. A badly framed one wastes everyone's time. How to frame problems with SCQ, MECE, and honest assumptions.

Most of what you need done at work depends on people you don't manage. The seven sources of power, only one of which needs a title, and how to influence without authority.

Warehouses are governed but rigid and costly; lakes are cheap but ungoverned. The lakehouse puts warehouse features on open lake storage, and open table formats like Iceberg are what make it work.

How packets actually flow in Google Cloud the global VPC, regional subnets, firewalls and routes, and the pieces that connect you to the internet and beyond.

In event-driven systems the schema is the contract between teams that never talk. Without a registry, contract-first design, and validation at every stage, it rots into chaos.

Intuition, not math what a neuron actually computes, why stacking hidden layers unlocks real power, and what "depth" buys you.

Three ways a machine learns from labelled answers, from unlabelled structure, and from reward with real use cases and a simple guide to picking the right one.

The node → pod → container model and how Kubernetes keeps your declared state true then what a service mesh like Istio adds once you have services that need to talk.

Risk management isn't a document you file once. It's a continuous process plus a toolkit. The four steps, the four mitigation strategies, and how to match the right analysis tool to the question.

Audit and assessment aren't the same one is rigid and legal, the other flexible and advisory. The distinction, the compliance laws that drive both, the six-step control process, and the policy hierarchy underneath.

In a crisis, speed beats perfection there's a recovery window that closes fast. How to lead through one, and the personal resilience that lets you keep leading when it's hard.

ACID is four promises but the interesting part is how databases actually keep them under concurrency and crashes. Write-ahead logs, locking vs MVCC, and 2PC, demystified.

Behavioral interviews predict future behavior from past behavior. STAR turns a rambling anecdote into evidence if you spend your time on the right letters.

Reactive programming exists to handle scale without blocking threads. The journey from Netflix's microservice toolkit to the Reactive Streams spec and Project Reactor's Mono and Flux.

The full loop problem framing, data, cleaning, EDA, modeling, communication, and deployment and why the unglamorous early stages decide whether the whole thing works.

Finding PII at scale is a pattern-matching problem, and the algorithm you pick trades speed against multi-pattern support and context. Regex, classic string search, Aho-Corasick and ML, and why the answer is a hybrid.

IT governance is the system by which IT is directed and controlled. Its five domains, the crucial data-vs-information governance distinction, and how IT turns Porter's five forces into advantage.

The three roles that make a data science team work, a hiring process that actually predicts performance, and how to define success before you start.

CDC streams every row change downstream in real time. The four ways to capture it, log-based through triggers to polling and tools, ranked by overhead, reliability and latency.

Security rests on CIA, and cryptography delivers it through three tool types symmetric, asymmetric, and hashing. But none of it works without a trust model. The foundations, mapped to what they actually protect.

Disaster recovery and business continuity aren't the same thing. DR restores IT; BC keeps the business running. The distinction, the tiering that drives both, and the RTO/RPO targets that make them measurable.

Ignite is more than a cache it's an in-memory computing platform with three grids. The key idea: bring the compute to the data in memory instead of moving data to the compute.

RACI tells you who's responsible and accountable but not who actually decides. DARE fixes the gap by naming the decider, and the power of questions makes it work.

Cassandra modeling is the inverse of relational you start with the queries, not the entities, and the partition is everything. How to design keys, size partitions, and split the hot ones.

Distributed messaging forces a choice you never had locally: you can't get exactly-once for free. The delivery guarantees, why idempotency is the real answer, and how sagas replace distributed transactions.

A container isn't a lightweight VM it's an ordinary Linux process the kernel has fenced in and lied to. The two kernel primitives behind the whole illusion.

Cassandra has no leader every node is equal. So how does it stay consistent and repair itself? Tunable consistency, Merkle-tree anti-entropy, and Paxos-based lightweight transactions.

An architecture style is a high-level shape with built-in trade-offs pick one deliberately, not by default. The common styles, how to choose, and a closer look at Lambda Architecture for big data.

ERP integrates business processes, not functions one system, one data repository, no more silos. The problems it solves, the modules, the real benefits, and the costs that derail implementations.

The system design interview tests whether you can drive ambiguity to a working design. A repeatable six-step approach and why clarifying requirements first is the whole game.

Senior leaders don't have patience for the slow build. The Pyramid Principle is a thinking-then-writing technique that puts the answer first and makes your case land.

Big-O tells you how an algorithm scales with input not how fast it is. And the data structure you pick decides that scaling. The complexity classes, the core structures, and the specialized ones that power real databases.

The cheapest bug to fix is the one you catch in requirements. The systematic discipline of defining and verifying what to build elicitation, specification, modeling before a line of code. Revisited in 2026: why this 2012 discipline matters more than ever now that AI writes most of the code.