Database

Safely modifying legacy code without breaking things, including reading undocumented code, adding tests before changing, and applying minimal-impact strategies.

Reading and interpreting application logs effectively, including log level understanding, stack trace parsing, pattern identification, and extracting actionable insights.

Generating well-formatted Markdown documents with proper heading hierarchy, code blocks, tables, link references, image embedding, escaping, and linting.

Identifying and fixing memory leaks — common leak patterns, heap analysis, profiling tools, garbage collection understanding, and preventive techniques like WeakRef and proper cleanup.

Designing and working with microservice architectures including service boundaries, communication patterns, data consistency, and resilience strategies.

Planning and executing code migrations safely — database migrations, API version upgrades, framework migrations, feature flag driven rollouts, backward compatibility, data migration scripts, rollback plans, and testing migration paths.

Implementing modals and dialogs correctly with focus management, accessibility, and interaction patterns

Adding monitoring and observability to applications through metrics collection, structured logging, distributed tracing, health checks, alerting, and SLI/SLO definition.

Working effectively in monorepo codebases with package boundaries, workspace tools, shared dependencies, and scoped changes.

Coordinating changes across multiple files safely with consistency guarantees, dependency tracking, and partial-update prevention

Next.js application development patterns — App Router, server components, server actions, data fetching, middleware, route handlers, static generation, and metadata management.

Working with NoSQL databases effectively — MongoDB document design, Redis data structures, DynamoDB access patterns, denormalization strategies, eventual consistency, secondary indexes, TTL expiration, and atomic operations.

Adding telemetry to code systematically with traces, metrics, and structured logs

Working with Object-Relational Mappers effectively — Prisma, Sequelize, SQLAlchemy, TypeORM patterns for relation handling, migrations, query optimization, and transaction management.

Systematic verification of your own work through testing, diff review, regression checking, and scope validation before presenting results

Publishing packages to registries including npm and PyPI workflows, semantic versioning, changelog generation, pre-publish checks, handling breaking changes, and deprecation.

Running independent subtasks in parallel for efficiency while managing shared state, resource conflicts, and result merging

Integrating payment processing with Stripe/PayPal APIs, handling webhooks, subscriptions, refunds, PCI compliance, currency handling, and tax calculation.

Generating PDF documents programmatically including HTML-to-PDF conversion, template-based generation, layout control, compliance, and digital signatures.

Identifying and fixing performance issues — profiling before optimizing, common bottlenecks, Big-O awareness, caching strategies, lazy loading, measuring before and after, and avoiding premature optimization.

How to plan implementation before writing code — requirements analysis, identifying unknowns, architectural decisions, file impact analysis, choosing between approaches, and knowing when a plan is needed vs when to just start.

Communicating progress effectively during long tasks — when to update, what to share, and how to structure status messages without overwhelming the user.

Idiomatic Python development — PEP 8 style, type hints, virtual environments, package management, comprehensions, context managers, decorators, dataclasses, and testing with pytest.

Implementing job queues and background processing — queue selection, retry policies, dead letter queues, concurrency control, and reliable idempotent job execution.

Implementing rate limiting and throttling — token bucket, sliding window, distributed limiting, response headers, and graceful degradation under load.

The ReAct (Reason + Act) pattern for structured problem solving, alternating between thinking and doing while maintaining a coherent reasoning trace.

Modern React development patterns — hooks, custom hooks, component composition, context usage, state management selection, render optimization, error boundaries, and suspense.

Safe refactoring techniques for autonomous agents — extract method/class, rename with propagation, dead code removal, simplifying conditionals, reducing duplication, maintaining backward compatibility, and refactoring in small verified steps.

Writing correct and efficient regular expressions for code manipulation, including avoiding catastrophic backtracking, testing strategies, and knowing when regex is the wrong tool.

Building responsive layouts across devices using mobile-first approaches, flexbox and grid, fluid typography, container queries, and thorough cross-device testing.

Evaluating risks before taking actions — classifying operations by reversibility, blast radius, and impact to decide when to proceed vs pause and confirm.

Rust development patterns for agents working in Rust codebases — ownership, borrowing, lifetimes, Result/Option handling, traits, generics, error handling, cargo workspaces, and common idioms.

Staying focused on what was actually requested — avoiding feature creep, not refactoring code you were not asked to touch, minimal viable changes, recognizing gold-plating, asking before expanding scope, and the discipline of

Resisting the urge to over-engineer, gold-plate, and bundle unrequested changes with simple fixes

Adding search functionality to applications including full-text search, Elasticsearch/Algolia/Meilisearch patterns, indexing strategies, relevance tuning, and autocomplete.

Handling secrets and credentials safely throughout the development lifecycle

Security considerations during code generation — avoiding injection vulnerabilities, secrets management, input validation, safe defaults, recognizing insecure patterns, and OWASP top 10 awareness.

How to detect, diagnose, and recover from mistakes during autonomous execution without cascading failures

Finding code by meaning and concept rather than exact text matches

Building serverless applications with Lambda/Cloud Functions, including cold start optimization, event-driven design, state management, and deployment automation.

Managing sessions and cookies correctly including cookie attributes, session stores, security hardening, consent handling, and token-based alternatives.

Executing shell commands safely and effectively, including proper quoting, exit code handling, avoiding destructive operations, and cross-platform compatibility.

Correctly interpreting user requirements by reading between the lines, identifying gaps, and building accurate mental models of intent

Writing efficient SQL queries — index design, EXPLAIN analysis, join optimization, CTEs vs subqueries, pagination techniques, aggregate optimization, parameterized queries, and connection pooling.

Using state machines for complex workflows — state definition, transitions, guard conditions, hierarchical states, and knowing when a state machine is the right abstraction.

Maintaining coherent progress and context across context window boundaries and separate agent sessions

Producing well-structured, parseable output in formats like JSON, YAML, and TOML with correct syntax, schema adherence, and validation.

Pushing back on bad ideas instead of blindly executing user requests that will cause problems

Building performant data tables and lists with virtualization, sorting, and responsive patterns

How to break complex tasks into atomic subtasks with dependency awareness, scope estimation, and ambiguity handling

Identifying, quantifying, and communicating technical debt with actionable remediation plans

Using tests to drive autonomous development through red-green-refactor cycles, leveraging test failures as navigation signals, and building confidence through coverage.

Writing effective tests autonomously — test structure (arrange-act-assert), choosing what to test, edge cases, mocking strategies, integration vs unit decisions, test naming, avoiding brittle tests, and testing error paths.

Choosing the right tool for each subtask based on cost-benefit analysis, parallelization opportunities, and thoroughness calibration

Leveraging type systems effectively across languages including TypeScript, Python, Go, and Rust for safer, more expressive, and self-documenting code.

Advanced TypeScript patterns for agents — generic types, conditional types, mapped types, discriminated unions, type guards, utility types, declaration files, strict mode, and module resolution.

Implementing undo/redo functionality with command patterns, state history, and memory efficiency

Implementing URL routing in web applications with RESTful design and modern patterns

Effective web research techniques including query formulation, source evaluation, cross-referencing, and synthesizing findings into actionable intelligence.

Implementing and consuming webhooks with endpoint security, signature verification, idempotency handling, retry logic, payload validation, and dead letter queues.