Topics

Every codebase eventually hits a wall where adding features gets slower instead of faster. That's an architecture problem. These skills help you think through API design, component boundaries, data flow patterns, and system-level decisions before they calcify into technical debt. Whether you're designing a GraphQL schema, planning a migration, or deciding how to handle auth flows, the goal is the same: make the next six months of development easier, not harder.

Code review is where most teams either catch problems or wave them through. The difference usually comes down to knowing what to look for. These skills focus on the mechanical side of code quality: complexity analysis, refactoring patterns, security review, type safety, and the kind of structural issues that automated linters miss. They're for developers who want reviews that actually improve the codebase, not just approve the PR.

The difference between a 10x developer and everyone else is usually workflow, not raw talent. Git strategies, PR descriptions, dependency management, monorepo tooling, state management patterns — these are the things that compound daily. Shave five minutes off your feedback loop and you've bought yourself hours by the end of the week. These skills target the repetitive parts of development that eat time without you noticing.

Performance work is satisfying because it's measurable — you either made it faster or you didn't. But knowing where to look is half the battle. These skills cover profiling, caching strategies, database indexing, ORM query optimization, and the data layer decisions that determine whether your app stays responsive at scale or falls over at the first traffic spike.

Most codebases don't have a testing problem — they have a testing strategy problem. Writing tests is easy. Writing the right tests, at the right level of abstraction, with the right tradeoffs between coverage and maintenance cost, is the hard part. These skills help you design test suites that actually catch regressions and write tests that don't break every time you refactor.

The worst bugs are the ones where you can reproduce the problem but can't figure out why it's happening. Debugging is a skill that compounds — the better your mental models for how systems fail, the faster you converge on root causes. These skills cover systematic debugging approaches, error handling patterns, and the kind of investigative thinking that turns a two-day mystery into a thirty-minute fix.

Prompt engineering is the difference between an LLM feature that works in demos and one that works in production. It's not about clever tricks — it's about understanding how models interpret instructions, where they fail predictably, and how to design prompts that degrade gracefully. These skills cover system prompts, few-shot design, structured outputs, chain-of-thought, guardrails, and the iterative debugging process that turns a flaky prompt into a reliable one.

Shipping an LLM feature without safety testing is like shipping a web app without input validation — it's only a matter of time. These skills cover evaluation frameworks, safety reviews, adversarial testing, and the quality assurance practices specific to AI systems. The goal isn't to eliminate all risk — it's to know where the edges are and have a plan for when outputs go sideways.

LLM API costs have a way of surprising you at scale. A feature that costs pennies in development can run up thousands in production if you're not thinking about model selection, token efficiency, caching, and gateway architecture from the start. These skills cover the operational side of running LLM features: cost modeling, observability, streaming UX, and the infrastructure decisions that keep your AI features economically viable.

Building AI agents means dealing with a new category of engineering problems: non-deterministic execution, tool use reliability, multi-step planning, and failure modes that don't show up in unit tests. These skills cover agent architecture, workflow design, tool schema definition, and the practical patterns for building agents that can actually complete tasks reliably instead of spinning in loops.

Not every LLM use case fits neatly into a category. Sometimes you need to brainstorm ideas, explain a concept clearly, or summarize a long document. These skills cover the general-purpose applications of AI that make daily work faster — the kind of tasks where Claude Code acts less like an engineering tool and more like a thinking partner.

RAG sounds simple — retrieve context, stuff it in the prompt, get better answers. In practice, it's a retrieval engineering problem. Embedding strategy, chunking, reranking, hybrid search, context window management — each decision affects answer quality in ways that are hard to debug after the fact. These skills help you build retrieval pipelines that actually surface the right information, not just the most similar vectors.

Security work is thankless until it isn't. Nobody notices when your IAM policies are correct, your secrets are properly managed, and your dependencies don't have known CVEs. They notice when any of those things fail. These skills cover the practical side of application and infrastructure security: access control, container hardening, dependency scanning, compliance frameworks, and the network-level decisions that keep attackers out.

Infrastructure work is where small decisions have outsized consequences. A misconfigured Terraform module or an under-provisioned database doesn't just cause a bug — it causes an outage. These skills help you review infrastructure code, plan migrations, optimize cloud costs, design network topologies, and manage the Kubernetes manifests and backup strategies that keep production running.

Your deployment pipeline is either your best friend or your biggest bottleneck. Slow CI, flaky tests, manual deployment steps — these are the things that turn a five-minute hotfix into a two-hour ordeal. These skills cover pipeline design, Dockerfile optimization, feature flags, alerting configuration, and zero-downtime deployment strategies that let you ship with confidence instead of anxiety.

Incidents are inevitable. How you respond to them is what separates mature engineering orgs from chaotic ones. These skills cover the full incident lifecycle: preparation through chaos engineering, response through playbooks and on-call processes, and learning through blameless postmortems and disaster recovery planning. The goal is to make incidents boring — handled by process, not heroics.

You can't fix what you can't see. Observability is about building the instrumentation that lets you understand what your system is actually doing, not just whether it's up or down. These skills cover logging strategies, monitoring setup, SLA/SLO design, load testing, and observability pipeline architecture — the difference between guessing why something broke and knowing within minutes.

Content that performs well has one thing in common: it was written for a specific reader with a specific problem. Not for "audiences" or "personas" in the abstract. These skills cover the full range of written content — blog posts, emails, newsletters, landing pages, product descriptions, social copy, video scripts — with a focus on writing that earns attention rather than demanding it.

Good content strategy starts with knowing what your competitors are doing, what your audience actually cares about, and where the gaps are. These skills cover the research and planning side of content marketing: audience personas, competitive analysis, content briefs, and SEO strategy. The work that happens before anyone writes a single word — and determines whether that word will matter.

Conversion optimization is a discipline, not a guess. Every CTA, ad variant, and landing page headline is a hypothesis that should be tested. These skills cover the mechanics of conversion-focused writing: ad copy that passes the scroll test, CTAs that actually get clicked, and A/B testing approaches that produce statistically meaningful results instead of noise.

Brand consistency is what makes your content recognizable across channels, and analytics is how you prove it's working. These skills cover brand voice definition, consistency auditing, and content performance analysis. Because creating content without measuring its impact is just journaling.

Strategy is choosing what not to do. Planning is making sure the things you chose actually happen. These skills cover the full arc of strategic work: business plans, go-to-market strategy, OKR design, product roadmaps, risk assessment, partnership evaluation, and stakeholder management. For people who need to turn ambiguity into a plan that a team can execute.

Good product decisions are downstream of good research. But most teams skip the research or do it badly — confirmation bias dressed up as market analysis. These skills cover competitive intelligence, market research, user interviews, survey design, due diligence, and literature review. The kind of structured investigation that turns opinions into evidence.

Financial models aren't predictions — they're thinking tools. A good model forces you to articulate your assumptions and see where your business breaks. These skills cover financial modeling, unit economics analysis, and pricing strategy. Whether you're preparing for a fundraise or just trying to figure out if a new feature is worth building, the numbers should drive the conversation.

The best strategy in the world doesn't matter if you can't communicate it. Board decks, pitch presentations, and stakeholder updates are where ideas either gain momentum or die quietly. These skills cover the communication layer of product and strategy work — turning analysis into narratives that get buy-in, funding, and alignment across teams.

The gap between "technically documented" and "actually usable" is where most developer experience falls apart. Tutorials, onboarding guides, FAQs, runbooks, and i18n guides all serve different purposes, but they share a common goal: get the reader from confused to productive as fast as possible. These skills focus on documentation that teaches, not just describes.

Technical writing isn't just documentation — it's communication. Incident reports, style guides, glossaries, knowledge bases, and technical blog posts all require the ability to explain complex things clearly to different audiences. These skills cover the broader communication work that technical writers do beyond pure docs: building shared vocabulary, maintaining consistency, and telling stories about technical work.

Documentation debt compounds just like technical debt, but it's harder to see. Outdated API docs, missing docstrings, and READMEs that describe the project as it was six months ago — these cost every new developer hours of confusion. These skills cover the documentation that lives closest to the code: API references, docstrings, code comments, architecture diagrams, and the READMEs that are often the first thing someone reads about your project.

Release communication is a surprisingly high-stakes writing task. Changelogs, release notes, and migration guides determine whether your users upgrade smoothly or open support tickets. These skills cover the documentation that surrounds every release: what changed, why it matters, and how to handle breaking changes without breaking trust.

Every error message, tooltip, and button label is a tiny piece of documentation embedded in your product. Bad UX copy creates support tickets. Good UX copy prevents them. These skills focus on the microcopy that shapes how users experience your software — the words that show up at the exact moment someone is confused, frustrated, or trying to make a decision.

Data engineering is plumbing — unglamorous, invisible when it works, and catastrophic when it doesn't. ETL pipelines, data cleaning, schema migrations, quality rules, privacy compliance, and the connectors that move data between systems. These skills cover the infrastructure layer that makes analytics possible. Because the fanciest dashboard in the world is worthless if the data feeding it is wrong.

Your data model is the foundation everything else is built on. Get it wrong and you'll spend the next year writing workarounds. These skills cover dimensional modeling, data warehouse design, analytics event schemas, data catalogs, and the dbt models that transform raw data into something analysts can actually use. The decisions you make here ripple through every query and report downstream.

The point of analytics isn't to produce charts — it's to change decisions. Dashboards, reports, metric definitions, data visualizations, and statistical analysis all need to answer the question: "so what?" These skills cover the last mile of data work: turning numbers into narratives, building dashboards that people actually use, and defining metrics that measure what matters instead of what's easy to count.

SQL is still the most important language in data work, and writing correct SQL is only half the job. Writing SQL that performs well on real datasets, that's readable by the next person, and that doesn't silently produce wrong results — that's the other half. These skills cover query writing, performance tuning, optimization, and the practical SQL work that data teams do every day.