No built-in ESLint rule enforces your team-specific convention. Here is how to write a custom plugin with AST visitor setup, RuleTester tests, and auto-fix, using the ESLint 9 flat config format.
JavaScript Date is broken. Timezone bugs, daylight saving time surprises, and ambiguous date math cost teams hours every sprint. Here is how to use the Temporal API with the production-ready polyfill today, with patterns for timezone-aware scheduling, duration math, and calendar-safe date handling.
Automate your changelog generation, version bumps, and npm/git tag creation using conventional commits and semantic-release. A practical setup that runs in CI and eliminates manual release work.
ESLint covers the common cases. For everything else there is the TypeScript Compiler API. This post walks through building real custom analysis tools: enforcing domain boundaries between packages, detecting leaked internals, and writing refactoring scripts that understand your codebase.
REST and GraphQL both leak a type gap between server and client that costs you a production bug every few sprints. tRPC eliminates that gap entirely. Here is how to build a production tRPC API with authentication, error handling, middleware, and rate limiting, without a code generator or a spec file.
Stop hand-writing fetch wrappers that drift from the spec. Here is how to generate fully typed API clients from OpenAPI specs, catch breaking changes in CI, and never debug a "but the API returned field X" production issue again.
Every team has a handful of internal CLI tools that are fragile, undocumented, and produce output no script can parse. Here is the structured argument parsing, exit code discipline, JSON output mode, and testing pattern that turns a glue script into a tool people trust in CI and at 2 AM.
The Docker Compose setup that worked on day one is broken by day thirty: stale volumes, mismatched bind mounts, services that start before the database is ready. Here is the pattern for local dev environments that survive a team of ten without every other developer running a different setup.
Production broke after a three-day sprint and two hundred commits. Hunting the culprit by hand is linear and slow. Git bisect turns it into a logarithmic search, and git bisect run automates the entire hunt. Here is the exact workflow, the test script template, and the CI integration that catches regressions before the next standup.
A step-by-step optimization of a real Node.js Docker image, from a 1.2GB monster to a 78MB production container. Each technique is benchmarked, copy-paste ready, and explained with the trade-offs.
GitHub Copilot, Cursor, Claude Code, Codeium, Tabnine. I integrated each into my daily workflow for a week each. Here is my honest take on what actually helps you ship.
A no-fluff guide to shipping a real CI/CD pipeline that lints, tests, builds, and deploys automatically, without the enterprise boilerplate.
Most devs reach for console.log when they should be using breakpoints, watch expressions, and conditional breakpoints. Here are the techniques that changed how I debug.
Most teams have unstated review standards that two senior engineers disagree about. The result: long inconsistent reviews, slow PRs, and frustrated authors. A short, written, agreed-upon checklist solves it. Here is one that works, and the meta-rule that keeps it from becoming another bureaucratic process.
Most teams write the API, then write the OpenAPI spec, then watch them diverge until the docs are useless. The fix is to make the spec the source of truth: generate types, validation, mocks, and clients from it. Here is the workflow that survives, and the tools that make it tractable.
SemVer is simple on paper and dishonest in practice. Most maintainers ship breaking changes in patches and call it "a bug fix." Here is what each version part actually means, the four kinds of changes that look like patches but aren't, and the deprecation playbook that lets you evolve a public API without breaking the world.
Most teams install Husky, configure ten pre-commit checks, and disable the whole thing within a month because commits take 30 seconds. Here is the minimal pre-commit setup that catches real bugs, runs in under 2 seconds on the changed files only, and does not need a `--no-verify` workaround.
Flipping `strict: true` on a 200-file TypeScript codebase produces 8000 errors and a team revolt. The right migration is incremental, file-by-file, with the seven flags enabled in the right order. Here is the plan that has worked on three real codebases.
The rebase-vs-merge debate is a proxy for a more useful question: what should the history of `main` look like a year from now? Here is the policy that answers it, applied to feature branches, long-lived branches, and the cases where you really should preserve the merge.
Most teams have one feature-flag system and four kinds of flags pretending to live in it. Release toggles, ops toggles, permission toggles, and experiments behave differently, decay differently, and need different cleanup rules. Here is the taxonomy that prevents flag debt from eating your codebase.
Half the production incidents that start with “but the script said it succeeded” come from the same three missing lines at the top of a bash file. Here is what set -euo pipefail actually does, the traps it has, and the deploy-script pattern that fails loudly instead of quietly succeeding.