# jsmanifest > A technical blog about JavaScript, React, TypeScript, Next.js, and modern web development. Author: Christopher Tran — Software Engineer & Technical Writer (https://jsmanifest.com/about). ## Posts - [TypeScript 6.0 Strict Function Types: Why Contravariance Breaks Your Existing Callbacks](https://jsmanifest.com/typescript-contravariance-strict-function-types): TypeScript 6.0 makes strictFunctionTypes the default, breaking callbacks that relied on bivariant parameter checking. Learn why contravariance matters and how to migrate production code without sacrificing type safety. - [TypeScript 6.0 --moduleDetection Force: Why Your Ambient Declarations Broke and How to Fix Them](https://jsmanifest.com/typescript-moduledetection-force-ambient-declarations): The moduleDetection: force option breaks ambient declarations by treating all .d.ts files as modules. Learn the three detection modes, why this change matters, and two proven patterns to fix your type definitions. - [React 20 ref as a Prop: Migrating Away From forwardRef Across a Large Component Library](https://jsmanifest.com/react-20-ref-prop-forwardref-migration): Eliminate forwardRef in React 20 component libraries by treating ref as a standard prop. Migration patterns, TypeScript updates, versioning strategy, and testing approaches for production codebases. - [Next.js Image Optimization in 2026: `next/image` v4, AVIF by Default, and the Config Changes Teams Miss](https://jsmanifest.com/nextjs-image-v4-avif-config): The configuration defaults that ship with next/image v4 break production image pipelines. Learn the AVIF format switch, remotePatterns migration, and cache settings that prevent silent failures. - [Claude Code vs Cursor vs Windsurf in 2026: Which Agentic IDE Actually Ships Production Code](https://jsmanifest.com/claude-code-cursor-windsurf-production-2026): Most teams pick agentic IDEs based on marketing claims instead of production realities. This technical comparison shows which tool ships real code in multi-file refactorings, context-heavy debugging, and team workflows. - [Claude Code Environment Variables and Secrets in 2026: What Gets Passed to Subagents and What Does Not](https://jsmanifest.com/claude-code-env-secrets-subagents): Most secret leakage in Claude Code stems from misunderstanding what environment data subagents inherit. This post maps the three-layer isolation model and shows production patterns for scoping credentials per subagent without vault complexity. - [TypeScript Intersection Types Done Right: When They Compose Cleanly and When They Silently Lie](https://jsmanifest.com/typescript-intersection-types-composition-pitfalls): Most TypeScript composition failures stem from misunderstanding intersection types. Learn when they compose cleanly, when they produce never, and how to avoid the silent lies that break production code. - [TypeScript 6.0 `--noPropertyAccessFromIndexSignature`: The Flag That Forces Honest API Contracts](https://jsmanifest.com/typescript-nopropertyaccessfromindexsignature-strict-api-contracts): Most runtime property access errors stem from index signatures pretending to guarantee properties they don't. This flag exposes the lie and forces honest API contracts. - [TypeScript 6.0 Type-Only Imports Are Now Enforced: What verbatimModuleSyntax Actually Breaks in Real Codebases](https://jsmanifest.com/typescript-verbatim-module-syntax-breaking-changes): The verbatimModuleSyntax flag eliminates elision guessing, but it breaks mixed import statements, re-exports, and side-effect modules in production codebases. Here's what actually fails and how to fix it. - [Debugging Claude Code Agents: Reading Transcripts, Tracing Tool Calls, and Finding Where Your Agent Goes Wrong](https://jsmanifest.com/debugging-claude-code-agents-transcripts-tool-calls): Master the techniques for debugging AI agents in production: reading execution transcripts, tracing tool calls, identifying failure patterns, and building custom analyzers that catch problems before users do. - [Claude Code Memory Strategies in 2026: Project Memory, User Memory, and When to Use Each](https://jsmanifest.com/claude-code-memory-strategies-2026): Most Claude Code productivity problems stem from mismatched memory layers. This post reveals the three-tier memory architecture—CLAUDE.md, user memory, and auto memory—and when to apply each for maximum consistency. - [TypeScript Awaited and Deep Promise Unwrapping: Patterns for Async Type Inference That Actually Work](https://jsmanifest.com/typescript-awaited-deep-promise-unwrapping): Master TypeScript's Awaited utility type for recursive promise unwrapping. Learn when it fails, how to combine it with generics, and the patterns that prevent async type inference errors in production. - [TypeScript Enums Are Still Controversial in 2026: Here Is When to Use Them and When to Reach for const Objects](https://jsmanifest.com/typescript-enums-const-objects-2026): TypeScript enums remain divisive after a decade. This guide breaks down when enums make sense, when const objects are superior, and how to migrate between them without breaking production. - [TypeScript Strict Null Checks in 2026: Real-World Patterns for Handling `undefined` Without the Noise](https://jsmanifest.com/typescript-strict-null-checks-patterns-2026): Master strict null checks in TypeScript with battle-tested patterns that eliminate runtime null errors without drowning your codebase in defensive checks. - [TypeScript interface vs type in 2026: The Definitive Answer After Years of Debate](https://jsmanifest.com/typescript-interface-vs-type-2026): Most TypeScript confusion stems from misunderstanding interface vs type. This guide cuts through years of debate with production-tested patterns, real performance data, and a decision framework that eliminates guesswork. - [TypeScript 6.0 `--isolatedModules` Is Now the Default: What Every Build Pipeline Must Change](https://jsmanifest.com/typescript-isolated-modules-default-build-changes): TypeScript 6.0's new isolatedModules default breaks const enums, namespaces, and type-only imports. Here's how to fix your build pipeline before deployment fails. - [Claude Code in CI: Running Agentic Code Review, Test Generation, and Auto-Fix on Every Pull Request](https://jsmanifest.com/claude-code-ci-agentic-review-test-auto-fix): Run Claude Code autonomously in CI pipelines to perform code review, generate tests, and auto-fix failures on every pull request—with production patterns for cost control and safety. - [TypeScript `asserts` and Type Predicates in 2026: Writing Guards That Actually Narrow Correctly](https://jsmanifest.com/typescript-asserts-type-predicates-2026): Most TypeScript runtime validation fails because developers misunderstand when to use type predicates versus assertion functions. Learn the patterns that actually narrow types correctly in production codebases. - [TypeScript readonly Arrays and Tuples: When Immutability Saves You and When It Fights You](https://jsmanifest.com/typescript-readonly-arrays-tuples-immutability): Most readonly bugs stem from shallow enforcement and type widening. Learn when TypeScript's readonly protects your arrays and tuples—and when it silently fails. - [TypeScript 6.0 Project References at Scale: Incremental Builds, Composite Projects, and What Teams Get Wrong](https://jsmanifest.com/typescript-project-references-scale): Most monorepo build failures stem from misunderstood project references. Learn how composite projects, incremental builds, and tsc -b actually work—and the subtle configuration mistakes that destroy build performance at scale. - [TypeScript `never` in Practice: Exhaustive Checks, Impossible States, and Narrowing Dead Code](https://jsmanifest.com/typescript-never-exhaustive-checks): Master the never type for exhaustive checks, impossible state elimination, and compile-time guarantees. Learn practical patterns that catch bugs before they reach production. - [TypeScript exactOptionalPropertyTypes: The Strict Flag That Catches the Bugs strict Misses](https://jsmanifest.com/typescript-exactoptionalpropertytypes-strict-flag): Most production TypeScript bugs stem from a single assumption: that strict mode catches every type safety hole. It doesn't. The exactOptionalPropertyTypes flag exposes runtime crashes that strict mode silently permits—here's why teams overlook it and how to fix it. - [Next.js 16 Server Actions in Production: Patterns, Validation, and the Mistakes Teams Make at Scale](https://jsmanifest.com/nextjs-server-actions-production-patterns): Most Server Actions fail at scale because teams treat them as internal functions instead of public POST endpoints. Learn the production patterns for authentication, validation, multi-tenant authorization, and choosing between Server Actions and Route Handlers in Next.js 16. - [Claude Code Cost Control in Production: Token Budgets, Caching Strategies, and What the Billing Dashboard Hides](https://jsmanifest.com/claude-code-cost-control-production): Most Claude Code cost overruns stem from invisible context accumulation and cache misses. Learn token budgets, caching strategies, and production-grade cost control patterns the billing dashboard won't reveal. - [Claude Code Multi-Repository Agents: Coordinating Changes Across Monorepo Packages with Subagents](https://jsmanifest.com/claude-code-monorepo-multi-agent-coordination): How teams use Git worktrees and isolated subagents to coordinate breaking changes across monorepo packages without merge conflicts or context collision. - [TypeScript Recursive Types in 2026: Modeling JSON, Trees, and Deep Partial Without Hitting the Limit](https://jsmanifest.com/typescript-recursive-types-json-trees-deep-partial): Master recursive types to model JSON values, file systems, and nested data structures. Learn production patterns that avoid TypeScript's recursion depth limit while maintaining type safety. - [TypeScript 6.0 `--noEmit` and Type-Only Builds: Why Your CI Pipeline Should Never Call tsc for Output Again](https://jsmanifest.com/typescript-noemit-type-only-builds): Most CI pipelines waste minutes waiting for tsc to transpile code that production never uses. The --noEmit flag and type-only checks unlock parallel builds that finish 3x faster while catching every type error. - [TypeScript Abstract Classes vs Interfaces in 2026: Which to Reach For and When](https://jsmanifest.com/typescript-abstract-classes-vs-interfaces): Most TypeScript engineers misuse abstract classes and interfaces because they treat them as interchangeable. Learn the structural differences, performance implications, and decision framework that separates production-ready architectures from brittle code. - [TypeScript noUncheckedIndexedAccess in 2026: The Flag You Should Have Turned On Years Ago](https://jsmanifest.com/typescript-nouncheckedindexedaccess-compiler-flag): Most production crashes from undefined array access stem from a single compiler flag being off. Teams pay for this oversight twice a month. - [TypeScript Namespace vs Module in 2026: When Declaration Files Still Need Namespaces](https://jsmanifest.com/typescript-namespace-module-declaration-files-2026): Most TypeScript teams avoid namespaces entirely, but declaration files and third-party type augmentation still require them. Learn when namespaces remain essential and how to use them correctly. - [TypeScript Generic Constraints in Depth: `extends`, `keyof`, and the Patterns That Prevent Runtime Errors](https://jsmanifest.com/typescript-generic-constraints-extends-keyof): Master TypeScript generic constraints with extends and keyof to eliminate runtime errors. Learn the patterns production codebases rely on for type-safe property access and API design. - [TypeScript Variadic Tuple Types: Composing Function Signatures and Middleware Pipelines](https://jsmanifest.com/typescript-variadic-tuple-types-middleware-pipelines): Master variadic tuple types to build type-safe function composition and middleware pipelines that preserve argument types through transformation chains. - [TypeScript Declaration Merging in 2026: Augmenting Third-Party Modules Without Losing Type Safety](https://jsmanifest.com/typescript-declaration-merging-module-augmentation-2026): Master TypeScript declaration merging and module augmentation to extend third-party types safely. Learn when to use global vs module augmentation, avoid merge conflicts, and maintain type safety in production codebases. - [TypeScript 6.0 Module Resolution Overhaul: What Bundler Mode Actually Changes for Your Project](https://jsmanifest.com/typescript-bundler-moduleresolution-production): TypeScript 6.0's moduleResolution: bundler fundamentally changes how import paths resolve. Learn what breaks, when to migrate, and how to avoid production failures in modern toolchains. - [TypeScript const Type Parameters: Immutable Inference and When It Beats as const](https://jsmanifest.com/typescript-const-type-parameters-immutable-inference): Most TypeScript type widening problems in generic functions stem from a single overlooked feature: const type parameters. Learn when they beat as const and how to combine them with satisfies for maximum type safety. - [JavaScript Atomics and SharedArrayBuffer in 2026: Practical Patterns for Cross-Worker State](https://jsmanifest.com/atomics-sharedarraybuffer-cross-worker-state): Lock-free ring buffers, shared task queues, and multi-worker synchronization patterns that eliminate postMessage serialization overhead in production JavaScript applications. - [React 19 useFormStatus and useFormState: Build Accessible Forms Without Extra State Libraries](https://jsmanifest.com/useformstatus-useformstate-accessible-forms): Master React 19's native form hooks to build production-grade accessible forms with real-time validation, loading states, and screen reader support—no external libraries required. - [Next.js unstable_cache vs fetch Cache in 2026: Which One Actually Belongs in Your App](https://jsmanifest.com/nextjs-unstable-cache-fetch-cache-2026): The caching story in Next.js has evolved dramatically. Learn when fetch cache fails, why unstable_cache exists, and how the use cache directive changes everything for production apps in 2026. - [The Power of Correlation IDs for AI Agents](https://jsmanifest.com/correlation-ids-ai-agents): Correlation IDs turn a scatter of disconnected logs into one queryable timeline. This guide shows how they let AI agents debug distributed systems faster, unlock new UI features, and reason across every boundary a request crosses. - [We Analyzed Over 1,500 CLAUDE.md and AGENTS.md Files on GitHub — Here's How Developers Actually Configure AI Agents](https://jsmanifest.com/we-analyzed-over-1500-claude-md-agents-md-files): Original data: 1,562 real agent-config files from 1,532 public repos — the CLAUDE.md vs AGENTS.md split, file sizes, most common sections, rule counts, and MCP adoption. - [TypeScript Discriminated Unions: Make Illegal States Unrepresentable](https://jsmanifest.com/typescript-discriminated-unions-illegal-states): Learn how TypeScript discriminated unions model state so invalid combinations simply won't compile. Master the discriminant pattern, exhaustiveness checking with never, and dramatically cleaner reducers. - [TypeScript Template Literal Types: Advanced Patterns for String-Safe APIs](https://jsmanifest.com/typescript-template-literal-types-string-safe-apis): Master template literal types to eliminate runtime string errors in route handlers, event emitters, and CSS-in-JS. Learn when to use template literals over string enums and how recursive patterns catch invalid paths at compile time. - [TypeScript Decorators Done Right: Migrating from Legacy to the TC39 Standard](https://jsmanifest.com/typescript-decorators-legacy-tc39-migration): Most decorator migration failures stem from treating TC39 standard decorators as a drop-in replacement. The API changed fundamentally—here's how to convert experimentalDecorators without breaking production. - [The TypeScript `satisfies` Operator in 2026: Patterns You Are Still Missing](https://jsmanifest.com/typescript-satisfies-advanced-patterns-2026): Five advanced patterns that unlock the full power of TypeScript's satisfies operator—from type-safe configs to branded types that bridge runtime validation with compile-time safety. - [TypeScript 6.0 Released: Every Breaking Change You Need to Know](https://jsmanifest.com/typescript-6-breaking-changes): TypeScript 6.0 marks the final JavaScript-based release with strict defaults, ES5 removal, and breaking tsconfig changes. Here's what breaks and how to fix it. - [TypeScript 6.0 isolatedDeclarations: What It Actually Replaces and Why It Matters](https://jsmanifest.com/typescript-isolated-declarations-what-it-replaces): TypeScript 6.0's isolatedDeclarations replaces the type checker bottleneck in .d.ts generation, enabling parallel builds and sub-second declaration emit in monorepos. - [TypeScript Branded Types vs. Nominal Types: Which Pattern Should You Use in 2026](https://jsmanifest.com/typescript-branded-types-nominal-typing): Most type safety failures in TypeScript stem from treating all strings as interchangeable. Branded types prevent these errors at compile time without runtime overhead. - [TypeScript using Keyword and Explicit Resource Management: Done Right](https://jsmanifest.com/typescript-using-explicit-resource-management): TypeScript's using keyword and explicit resource management eliminate the most common source of production memory leaks. Learn the patterns that matter. - [Migrating a 200k-Line Codebase from TypeScript 5.x to 6.0: What Actually Broke](https://jsmanifest.com/typescript-5-to-6-migration-200k-lines): A detailed account of migrating 200,000 lines from TypeScript 5.x to 6.0, covering the three breaking changes that generated thousands of errors, the migration strategy that failed first, and the tooling that ultimately saved the project. - [How TypeScript Infers Types Through Async Generators in 2026](https://jsmanifest.com/typescript-async-generator-type-inference): Most async generator type errors stem from TypeScript's inability to infer yield types. This post reveals the three-parameter type system that eliminates inference failures in production code. ## Key pages - [About](https://jsmanifest.com/about): About Christopher Tran and jsmanifest. - [All posts](https://jsmanifest.com/posts)