What the Code Proves

Evidence

• Multiple full-stack ecosystems spanning 15+ repositories across web, mobile, desktop, API, database, and infrastructure layers — all deploying to the same AWS account with disciplined isolation.
• Domain Completeness Framework with machine-readable manifest and automated audit script to enforce vertical slices through every layer.
• Three-tier PostgreSQL schema design (api_v1 → private_logic → data) — a pattern born from watching systems degrade when applications reach directly into storage layers.

Why It Survives

An agent can write a component or a function. It cannot decide that domain objects need a complete vertical slice through every layer of the stack, then design a framework to enforce it. That's architectural vision — the ability to see the whole system and define what "done" means across it.

Evidence

• Current role: "Help cultivate growth of engineers and determine what an engineer looks like in the age of AI assistance."
• Documentation hierarchy (AGENTS.md → CLAUDE.md → .cursor/rules → copilot-instructions) — building systems that make other developers and agents more effective.

Why It Survives

This is a leadership problem, not a coding problem. What should a junior engineer learn? How do you evaluate work when the agent wrote the code? What does "senior" mean when everyone has a tireless coding assistant? The industry needs people who can answer these questions.

Evidence

• Geospatial systems — USTRANSCOM's GLS, Esri/Mapbox, logistics visualization. Geospatial prototyping in vanilla JavaScript before frameworks existed.
• Defense logistics — Scheduling and tracking movement of troops and equipment for joint US and allied forces. JALIS system supporting classified missions.
• Aviation SaaS — Boeing Digital Airline Solutions: full SaaS platform for parts service and inventory with dynamic data service layers.
• Data engineering — Heavy data feeds, transformations, pipelines, and visualizations across every role.

Why It Survives

An agent doesn't know that a Tanker Air Refueling platform needs to show air bases, refueling missions, and units needing refueling. Domain knowledge is the context that turns generic code into working software. 25 years of contexts that no model was trained on.

Evidence

• "No silent failures. No fake responses. No swallowed exceptions."
• Every NEVER/ALWAYS rule maps to a real production incident or debugging nightmare.
• Every except block must re-raise, raise new, or log with context.

Why It Survives

Agents are prolific producers of plausible code that silently fails. They'll catch exceptions and return empty defaults. They'll skip auth checks for convenience. Quality standards are the guardrails that keep agent output production-grade. The person who defines and enforces these standards is more valuable than the person who writes the code.

Evidence

• Multi-stage Docker builds with layer caching optimization.
• Docker Compose variants (prod vs dev with hot-reload and volume mounts).
• AWS CodeBuild → ECR → ECS/Fargate deployment pipeline.
• OpenTofu (not Terraform) infrastructure-as-code.
• Step Functions orchestrating ECS Fargate agent workers.
• GitHub Actions CI with full quality gate pipeline.
• Multi-workspace AWS isolation with state separation.

Why It Survives

Someone needs to decide how code gets deployed, design the container strategy, configure the CI pipeline, and ensure workspaces don't stomp on each other's resources. The AWS Agent Workers architecture (Step Functions → ECS Fargate → S3) is a production system that runs AI agents at scale.

Evidence

• 4-tier AI documentation hierarchy across every project.
• Database-driven agent architecture (agents, instructions, tools, teams all in PostgreSQL).
• AgentFactory pattern for composable agent creation.
• 28+ registered agents across multiple API platforms.
• RTK (Rust Token Killer) — a token-optimized CLI proxy for agent interactions.
• Multi-LLM provider support (Groq, OpenAI, Anthropic, Google, DeepSeek).

Why It Survives

Most people use agents. This is architecting systems of agents. Database-driven, composable, testable artifacts — not ad-hoc prompts. Each agent is a vocabulary word; the value is in the composition.

Evidence

• OKLch color space usage (perceptually uniform — not just grabbing hex codes).
• Accessibility-conscious contrast ratio annotations in CSS comments.
• Interactive Mapbox-based career timeline (not a boring list).
• Framer Motion animations with multiple overlay/size variants.
• Component variants via CVA (class-variance-authority).
• Storybook served in production as living documentation.

Why It Survives

An agent can generate a component that works. Making it feel right — choosing the right animation curve, the right contrast ratio, the right interaction pattern — requires taste. Presenting a career as an interactive map communicates identity, not just information.

Evidence

• Early Scrum adopter, certified SAFe Scrum Master.
• Fixture-driven development with co-located mock data.
• Three-level testing strategy (unit → interaction → visual regression).
• Local verification mandatory before any push.
• Pre-commit hooks (Husky + lint-staged) — and explicit rules to never skip them.

Why It Survives

Process is the multiplier. Good process means agents produce better output (guardrails catch mistakes), developers onboard faster (patterns are documented), and the system stays healthy over time (quality gates are automated, not manual).