AI can write most of the code now. What it can't do is decide what to cache, what not to build, which upgrade silently broke a guarantee, or which 403 leaks information. Those decisions are the job, so instead of a skills list, here is each competency employers actually hire for, paired with the artifact that proves it: a file, a test, a measured number, or a decision recorded with its reason. Every link opens the real thing.
A note on NextAurora. It is architected as a large-scale distributed system: independently deployable services, their own databases, a durable broker, horizontal scale-out per service. The public demo deliberately runs it in one Aspire host and one repository so it can be developed and shown on a single box. The receipts below point at the architecture, not the demo topology.
Why these are personal projects. The professional work runs inside a tribal government network, in secure Azure environments, or behind auth. None of it is public: the financial platform, the migrations, the pipelines, the Power Platform estate. What's below is what I can hand you, built on my own time, in the open, breakable on purpose. The rest is on the experience page, where you'd have to take my word for it. I'd rather mark that line than blur it.
Knowing where the runtime bites — allocation, GC mode, index locality, blocking calls — before profiling tells you.
Versioning, error contracts, and long-running writes decided once, in one place, so five services can’t drift.
Reads project to DTOs inside the query; writes load the aggregate tracked. The split is the rule, not a later cleanup.
Background jobs have traps the request pipeline hides; topology is code; shipping is a pipeline, not a person.
Authorization is only proven by an authorization-failure test. A clean build and green unit tests are not evidence.
Each store exists because a question needed it, and the write path owns invalidation.
gRPC where the caller needs the answer now; events where the work can outlive the request. Never a stream just to avoid losing messages.
Exactly-once delivery is impossible, so every failure is pushed toward duplication and duplication is made a no-op: entity and envelope commit together, and every consumer can be handed the same event twice.
A failure you can’t follow across a service boundary, or pin to a pipeline stage, is one you fix by guessing.
The dependency rule is always on; the project split is the only part that costs, so it has to earn its way in.
Major versions change semantics silently. The regression that doesn’t throw is the one that costs you.
Decisions are recorded with their reasons, including the reversed ones, so the next person inherits judgment, not just code.
Review should be encoded, not remembered: every finding becomes a rule the next review applies automatically.
A catch that lives only in a PR gets re-made six sessions later; the loop encodes it once, on the smallest surface that holds it, and OKL carries it to every connected repo.
Handlers that touch the database are tested against real databases in containers, not mocks of the ORM.
Start from what the user needs to decide; be honest about what the system is and isn’t.
Typed, tested, CI-gated Python for data engineering and services, not notebooks that happen to run.
Feature-sliced React 19 + TypeScript, state that is testable without a browser, and UI that explains a distributed system.
Hybrid retrieval, corrective grading, structured facts where similarity fails, and an eval harness with the power to say no.
An agent where it earns its keep: allowlisted read-only tools, and a router that decides per question whether to use it at all.
Multi-source geospatial ingestion, weak labels, spatial cross-validation, and results recorded with dates, including null results and retractions.