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.
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; deploys should be boring enough to forget.
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.
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 dates and 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.
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, a page of explicit code, 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.
Two things on the usual list I've done in professional work but can't link to: migrating legacy .NET Framework code to modern .NET without breaking production, and running a document-oriented NoSQL store at scale. Those live on therésumé side, not the receipts side — and I'd rather say so than pad the table.