The Compound Effect of Skills, Eight Months In

When I started writing daily in April, each skill felt separate. Python over here. Next.js over there. Serverless patterns somewhere else. Eight months later, the boundaries have dissolved. The compound effect of adjacent skills is the single most underrated property of a generalist practice.

What Compounding Looks Like

A year ago, adding search to a content site meant learning an Elasticsearch stack. This week, I added search by combining three things I already knew: DynamoDB streams, Lambda triggers, and a small FastAPI index endpoint. No new service. No new bill. The skills I already had, permuted, solved the new problem.

Compounding shows up as: new problems that used to require new tools now resolve in tools I already own. That is the real return on a broad practice.

The Three Conditions for Compounding

Adjacency. Random skills do not compose. Python plus Lambda plus DynamoDB compose because they share a mental model: event-driven, stateless, pay-per-call. Skills compound when they share a backbone.

Depth. A skill you cannot actually ship with does not compound. Surface familiarity with ten tools beats shipping with zero of them. Compound returns require that each skill is production-ready on its own.

Frequency. Skills used once a year do not compound, they evaporate. Daily practice keeps them live. That is why the content cadence matters. It forces me to exercise each skill on a real example at least monthly.

A Concrete Inventory

Backend:    FastAPI, Django, Pydantic, async Python
Data:       DynamoDB single-table, Postgres basics
Infra:      Lambda, SES, SQS, EventBridge, CloudFront, SAM
Frontend:   Next.js App Router, Tailwind, MDX
CMS:        WordPress (blocks, themes, plugins), Strapi
AI:         Claude Code, Cursor, Codex, MCP authoring
Ops:        git, Docker, CI/CD, structured logging

Each row is one layer. A client problem rarely sits in one row. The value is in the combinations: search is Data plus Infra plus Backend, for example.

Why Specialists Lose This Race

A specialist is faster in their niche and slower everywhere else. Agent-assisted development flattens the speed advantage inside the niche (the agent writes most of the boilerplate) while amplifying the cost of narrowness (you hit walls in every adjacent layer). The generalist with agents wins because the agent covers the depth and the human covers the breadth. See the T-shaped developer framing for the pre-AI version of this argument. Agents turn T into a much wider letter.

Compounding is the whole thesis. Eight months of proof has earned the claim.