Results for “test”

Migrate test files from `as` type assertions to @total-typescript/shoehorn, using fromPartial and fromAny for partial or intentionally wrong test data.

Restructure code while preserving behavior: confirm tests are green, refactor in small steps, keep tests green, review, and commit with a gated workflow.

Guides adding characterization tests before modifying or refactoring untested legacy code, using the RGR workflow and strangler fig pattern to reduce risk.

Refactors production code with test coverage using a TDD workflow that applies approved refactorings one at a time, gates each on passing tests, and commits or reverts accordingly.

Safely change and test untested codebases using techniques from Feathers' 'Working Effectively with Legacy Code': seams, characterization tests, sprout/wrap, and dependency-breaking.

Migrate TypeScript test code from `as` assertions to type-safe `shoehorn` helpers like `fromPartial` and `fromAny`.

Write idiomatic C# code using .NET features, async/await, LINQ, SOLID principles, dependency injection, and unit tests.

Enforces system design, project structure, dependency management, error handling, testing, and documentation standards at principal-engineer level.

Splits, merges, moves, or deletes code while preserving behavior, tests, contracts, and boundaries, with characterization evidence and reversible steps.

Delivers changes incrementally by building in thin vertical slices, testing and verifying each piece before moving to the next.

Implements features, fixes bugs, and refactors code by orchestrating domain-specific skills, following existing patterns, and verifying tests and lint pass.

Orchestrate altering an existing, working feature to new desired behavior by updating tests first, then changing implementation, reviewing, and committing with gated approval.

Automatically detects project state and runs an 8-phase pipeline to plan, build, test, lint, fix bugs, and document code across multiple AI coding agents.

Ensure .NET/C# code meets project-specific best practices for structure, design patterns, dependency injection, async/await, testing, configuration, and security.

Test-driven development for Quarkus 3.x LTS using JUnit 5, Mockito, REST Assured, Camel testing, and JaCoCo. Use when adding features, fixing bugs, or refactoring event-driven services.

Delivers a small, bounded code change through inspection, a mini-plan, implementation, testing, review, and adversarial verification. Use for bug fixes, configuration changes, and features expected to touch no more than five files.

Applies the same change across multiple repositories in parallel using git worktrees, tests, and pull requests.

Write readable, maintainable code through disciplined naming, small functions, and clean error handling.

Refactors duplicated code by extracting helper methods, shared abstractions, or reusable structures, with automated testing and commits after each extraction.

Refactors code by renaming variables, methods, classes, and types to improve clarity and intent, with automatic testing and commits after each rename.

Sets up JavaScript/TypeScript projects with opinionated tooling and conventions including ESLint, TypeScript config, testing with Vitest, and monorepo setup.

Identifies and removes dead code safely, with test verification at each step and categorization of risk levels.

Write, review, debug, or test Python asyncio code involving coroutines, Tasks, TaskGroups, cancellation, timeouts, queues, synchronization, and blocking-call boundaries.

Write modern Perl 5.36+ code using idioms, best practices, and conventions for robust, maintainable applications.

Runs and interprets Elixir/Phoenix tooling (mix test, credo, dialyzer, format), generates OTP-conforming modules, and helps with Ecto and LiveView patterns.

Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks.

Transforms working code into clean, readable, and maintainable code following Robert C. Martin's principles.

Provides expert guidance on modern Rust development, covering async patterns, advanced type system features, and production-ready systems programming.

Reviews a codebase for structural smells and refactors them with provable safety, using micro commits and green-bar discipline.

Write, review, debug, or test Python code that parses, inspects, transforms, builds, qualifies, optimizes, formats, or transpiles SQL with SQLGlot.