Database

Working with Docker for development and deployment, including Dockerfile best practices, compose patterns, image optimization, and container debugging.

Writing useful documentation during development — README structure, inline comments, API documentation, architecture decision records, changelog entries, doc-as-code philosophy, and keeping docs close to code.

Implementing drag and drop interfaces with touch support, accessibility, and smooth animations

Building email and notification systems covering SMTP/API sending, template systems, queue-based delivery, bounce handling, unsubscribe compliance, push notifications, and delivery tracking.

Setting up and troubleshooting development environments across platforms, including version managers, virtual environments, PATH issues, and common failure patterns.

Preventing small errors from compounding into catastrophic failures through checkpoints, verification, and early termination

Implementing robust error handling with try/catch strategies, error hierarchies, error boundaries, graceful degradation, retry logic, and circuit breakers.

Reading and acting on error messages effectively — common error patterns by language and framework, stack trace navigation, distinguishing root cause from symptoms, search strategies for unknown errors, compiler vs runtime errors, and environment issues vs code bugs.

Implementing event-driven systems — pub/sub patterns, event sourcing, message queues, eventual consistency, and building reliable event handlers.

Using feature flags for safe deployments including flag types, gradual rollouts, A/B testing, flag cleanup, kill switches, user segmentation, and configuration management.

Safe and efficient file system operations including atomic writes, file locks, temp file patterns, directory traversal safety, path normalization, and cross-platform handling.

Implementing file upload systems including multipart uploads, chunked uploads, validation, virus scanning, storage backends, presigned URLs, and resumable uploads.

Implementing robust form systems with validation, accessibility, and state management

Advanced git operations including interactive rebase, cherry-picking, bisect, stash management, submodules, worktrees, reflog recovery, merge strategies, and git hooks.

Proper git usage during autonomous work — commit hygiene, meaningful messages, staging specific files, avoiding destructive operations, branch awareness, merge conflict handling, and preserving user work.

Go development patterns and idioms — error handling, goroutines, channels, interface design, package organization, context propagation, dependency injection, testing, and modules.

Building systems that fail partially instead of completely when dependencies are unavailable

Implementing and consuming GraphQL APIs including schema design, resolver patterns, N+1 prevention, mutation design, subscriptions, pagination, error handling, and federation.

Techniques to avoid generating false information by grounding responses in verifiable code and data

Making operations safe to retry without unintended side effects

Processing images and media in applications including optimization, responsive images, lazy loading, CDN delivery, video transcoding, and modern format adoption.

Delivering work in small verified increments — shipping the simplest working version first, building complexity gradually, verifying each increment, avoiding big-bang changes, keeping the project buildable, and using feature flags for partial work.

Managing infrastructure through code using Terraform, Pulumi, and CloudFormation, with emphasis on state management, safety, and environment separation.

Implementing i18n and localization including string externalization, ICU message format, pluralization, date/number/currency formatting, RTL support, locale detection, and translation management.

Advanced JSON processing and manipulation including deep merging, path-based access, schema validation, diffing, streaming large files, and preserving key ordering.

Implementing keyboard shortcuts with modifier keys, scoping, conflict resolution, and discoverability

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 "good enough."

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