Stack

The tools I build with and what I actually use each of them for. Depth varies: some I live in every day, others I pick up when a problem calls for them.

AI

Where most of my time goes right now: building products on top of models, and building the harness around them.

Claude Code: My daily driver for agentic development. I write my own skills, MCP servers and hooks for it, and I run agents inside Docker sandboxes.
OpenAI & Codex: The OpenAI and Responses APIs, including a gateway of mine that translates between OpenAI and Anthropic formats with provider failover.
MCP: Model Context Protocol servers for memory, knowledge bases and internal tools, so agents get context instead of guesses.
Vercel AI SDK: Streaming interfaces and model-agnostic calls: the layer I reach for in every React and Next.js product with AI in it.
Mastra: Typed agent workflows when a pipeline needs several agents handing work to each other.
LangChain: Orchestration for retrieval and multi-step LLM pipelines when a plain API call is not enough.
HuggingFace: Transformers.js and open models for embeddings, transcription and anything that should run locally instead of behind an API.
Agent frameworks: I build my own: a zero-dependency TypeScript agent framework, a CLI coding agent, and persistent memory servers for agents.

Languages

What I actually write code in, roughly in order of how much of it I write.

TypeScript: My default language on both sides of the wire, with strict mode and types shared end to end. Most of what I build starts here.
JavaScript: The runtime underneath everything. Plain JS for CLIs and scripts where a build step would only add friction.
PHP: Symfony and Doctrine codebases in production: maintaining them, refactoring them and moving pieces out into services.
Python: Indexing, data and ML-adjacent tooling, plus MCP servers where the Python SDK is the shortest path.
Swift: SwiftUI apps for iOS, built offline-first and shipped end to end.
Bash: Shell tooling, git workflows and the automation glue I live in every day.
HTML5: Semantic markup and accessibility as the baseline, not as a pass at the end.
CSS3: Modern layout, custom properties and container queries instead of piles of overrides.

Frameworks and runtimes

Rendering strategy first, framework second.

React: The component model I reach for by default, from product interfaces to terminal UIs and video compositions.
Next.js: Full-stack React: app router, server components and auth, for products that need a backend on day one.
Astro: Content-driven sites where shipping less JavaScript is the point. This site runs on it.
Angular: Large enterprise front-ends with SSR: evolving and maintaining applications that outlive their teams.
React Native & Expo: Cross-platform mobile apps with maps, audio and location, shipped through EAS.
Ionic: Hybrid mobile apps built from a single web codebase, with Capacitor underneath.
Tailwind: Utility-first styling on top of design tokens, instead of a bespoke CSS architecture.
Remotion: Video as React components: automated pipelines that turn a script into a rendered, published video.
Node.js: Services, background jobs and the CLI tooling I write to automate my own work.
Bun: My runtime of choice for CLIs and small services: one toolchain for install, run, test and bundle.
Deno: Modern runtime with sane defaults for scripts and small self-contained services.
Express: A minimal HTTP layer for the cases where a full framework would add nothing.
Fastify: Schema-first HTTP services when throughput and typed routes matter more than ecosystem size.
NestJS: Structured, dependency-injected services when a backend needs to survive a team.
Symfony: The backbone of the PHP systems I work on: Doctrine, CQRS and a decade of business rules.
GraphQL: Schema design and resolvers when clients need to shape their own payloads.

Data and storage

Picking the boring option on purpose, most of the time.

PostgreSQL: My default relational database, including geospatial search with PostGIS.
MySQL: Production OLTP databases: slow query analysis, execution plans and index work.
SQLite & libSQL: Embedded storage with full-text and vector search for local-first tools and agent memory.
Redis: Caching, rate limiting and the queues that sit between services.
MongoDB: Document storage for fast-moving schemas that are not ready to be normalised.
PocketBase: A single binary with auth, storage and realtime APIs, for products that need to exist next week.
Firebase: Push notifications and auth on mobile, where the platform integration is worth more than the database.
Supabase: Postgres with batteries: auth, storage and instant APIs without leaving SQL behind.

Infrastructure and tooling

Running things in production and knowing what they are doing.

AWS: ECS, RDS, S3, Lambda and CloudWatch for deploying and observing production services.
Docker: Reproducible local environments, multi-stage images for production, and sandboxes to run agents safely.
Fly.io: Where my side projects and self-hosted services live: deploy from a Dockerfile, forget about it.
Linux: Servers, Alpine images, shell tooling and the automation glue around everything above.
Nginx: Static serving, compression and reverse proxying in front of almost everything I deploy.
RabbitMQ: Asynchronous messaging between services when a request should not wait for the work to finish.
Git: Branching, worktrees, rebasing and a history I can still read six months later.
GitHub Actions: CI, releases to npm and deploys, so shipping is a merge and not a ritual.
Jenkins: The pipelines that build and deploy the microservices I work on day to day.
Biome & ESLint: Linting and formatting decided once, enforced automatically, never argued about again.
Vitest & Playwright: Unit tests where logic lives and end-to-end tests where users do.
PostHog: Product analytics and funnels: shipping a feature and then finding out whether it worked.
Jira: Planning and traceability when the work spans a team and several sprints.