Working guide
AI code refactoring with evidence
Use AI for bounded code refactoring while preserving behaviour. Define invariants, review the diff, challenge generated tests and keep a reversible patch.
Practical methods for testing, reviewing and improving code you already have.
Working guide
Use AI for bounded code refactoring while preserving behaviour. Define invariants, review the diff, challenge generated tests and keep a reversible patch.
Working guide
Generate unit tests with AI, then verify their assertions, isolation and failure sensitivity. Use boundary examples and a practical review worksheet.
Working guide
Reduce technical debt through evidence, prioritisation and small verifiable changes. Use an outcome-based worksheet and keep accepted compromises explicit.
Working guide
Refactor legacy code with characterisation tests, a narrow seam and small reversible changes. Use a worksheet to preserve behaviour before changing structure.
Working guide
Assess technical debt with evidence of change friction, defect risk and ownership. Use a practical matrix to turn repository findings into scoped backlog items.
Working guide
Check identity, tenant access, secrets, inputs and dependencies in a vibe-coded app. Use a practical worksheet with evidence and clear pass conditions.
Working guide
Assess a vibe-coded prototype before release: identity, data, failure handling, tests and rollback. Separate bounded repairs from missing product design.
Working guide
Review AI-generated code by checking its contract, trust boundaries, dependencies and tests. Use a practical diff review sheet tied to the final commit.
Working guide
Create a test automation strategy with risk priorities, test layers, data ownership, failure handling, and measurable feedback goals.
Working guide
Use Selenium WebDriver with clear assertions, explicit waits, isolated test data, and page objects that keep browser tests easy to diagnose.
Working guide
Plan C# unit tests around exact outcomes, asynchronous results, parameterized boundaries, dependency seams, and the repository's existing test framework.
Working guide
Compare test automation frameworks by execution model, fixtures, assertions, diagnostics, and fit with your application and team skills.
Working guide
Compare unit testing tools by discovery, assertions, fixtures, mocking, module support, diagnostics, and integration with the existing repository.
Working guide
Compare codeless testing tools through assertions, selector repair, data isolation, review history, custom logic, and export requirements.
Working guide
Evaluate test automation tools with practical criteria for test layers, assertions, debugging, integration, ownership, and maintenance effort.
Working guide
Build end-to-end checks for critical user journeys with controlled data, meaningful outcomes, clear system boundaries, and useful failure evidence.
Working guide
Combine visual test flows and small code extensions while keeping assertions, data setup, review, and ownership clear in low-code automation.
Working guide
Select security-oriented AI review tools by testing threat coverage, evidence quality, integration permissions, and how findings combine with existing scanners.
Working guide
Assess self-hosted AI review deployment by tracing source-code egress, model hosting, permissions, maintenance responsibilities, and repeatable review quality.
Working guide
Identify debt in AI-generated code through duplicated rules, unclear ownership, weak tests, and unsupported assumptions, then prioritize bounded repairs.
Working guide
Plan AI code review automation around pull requests, safe permissions, actionable findings, and measured reviewer value before introducing blocking checks.
Working guide
Evaluate AI-generated code for correctness, maintainability, integration fit, and test quality using concrete review questions and observable evidence.
Working guide
Compare AI-assisted refactoring providers by behavior preservation, repository fit, reviewer ownership, evidence, and bounded scope before engaging a team.
Working guide
Evaluate modernization providers by system fit, discovery quality, migration ownership, verification, and handover rather than unsupported vendor rankings.
Working guide
Compare test automation companies by repository access, test ownership, delivery evidence, maintenance costs, and a practical pilot scope.
Working guide
Review code for behavior, design, tests, and maintainability with a practical sequence that turns findings into clear, actionable changes for the author.
Working guide
Reproduce defects in AI-generated code, trace the failing boundary, and verify a focused fix with regression tests and useful diagnostic evidence.
Working guide
Build a software maintenance budget from system inventory, recurring work, incident uncertainty, verification, and ownership without invented averages.
Working guide
Compare AI code review tools using your repository, known defects, data requirements, integration needs, and operating cost rather than unsupported rankings.
Working guide
Measure technical debt with evidenced items, maintenance impact, effort ranges, and consistent trend signals while recognizing the limits of scanner scores.
Working guide
Build a practical remediation workflow for AI-generated code: verify authorization, remove exposed secrets, harden input boundaries, and retest fixes.
Working guide
Test JavaScript behavior with exact assertions, awaited promises, controlled clocks, module-aware setup, and a clear distinction between logic and DOM tests.
Working guide
Use Jest for explicit unit assertions, parameterized cases, awaited promises, controlled mocks, and cleanup that prevents state leaking between tests.
Working guide
Explore clearly labeled modernization scenarios and learn what evidence a real case study needs: baseline, implementation scope, verification, and outcomes.
Working guide
Integrate technical debt into Agile planning with explicit backlog items, quality expectations, focused acceptance checks, and evidence for product tradeoffs.
Working guide
Design test automation reporting around failed behavior, build identity, diagnostic evidence, flaky outcomes, and clear follow-up ownership.
Working guide
Organize application maintenance with clear intake, impact-based triage, accountable owners, acceptance checks, release planning, and review of repeat issues.
Working guide
Build a practical debt-management process with evidence, owners, prioritization, bounded interventions, and review of accepted tradeoffs and results.
Working guide
Choose a modernization sequence by mapping dependencies, testing boundaries, defining reversible increments, and planning data ownership and retirement.
Working guide
Choose mobile test layers and device coverage for permissions, lifecycle changes, navigation, and native app workflows with controlled test data.
Working guide
Apply extract function, guard clauses, parameter objects, and responsibility separation with examples, prerequisites, and checks for behavior preservation.
Working guide
Use Java refactoring techniques with attention to exception behavior, resource ownership, collection mutation, public signatures, and regression checks.
Working guide
Refactor JavaScript functions, modules, and promise flows while preserving async completion, errors, object mutation, and the public application contract.
Working guide
Refactor Python functions and modules with checks for mutation, iterators, exceptions, resource lifetime, and test isolation in the supported runtime.
Working guide
Plan continuous test automation with fast change checks, isolated data, clear failure artifacts, and separate stages for slower journeys.
Working guide
Identify security risks in AI-generated applications, from broken authorization to unsafe dependencies, and map each risk to evidence and controls.
Working guide
Explore illustrative technical debt examples in code, architecture, tests, delivery, and documentation, with evidence and bounded ways to reduce each problem.
Working guide
Use Terraform test files for module assertions, deliberate plan or apply choices, controlled provider behavior, and explicit infrastructure side-effect limits.
Working guide
Use AEM Mocks for focused Sling Model and service checks with controlled content, registered dependencies, clear adaptation assertions, and platform limits.
Working guide
Use Angular TestBed for component and dependency-injection checks, focused fixtures, controlled services, stable assertions, and explicit HTTP boundaries.
Working guide
Test FastAPI endpoints with TestClient, pytest, controlled dependency overrides, precise status and payload checks, and explicit integration boundaries.
Working guide
Write React component tests with Testing Library, accessible queries, awaited user interactions, controlled data, and clear limits of the DOM environment.
Working guide
Use dbt unit tests to check SQL model transformations with given inputs and expected rows, including joins, nulls, and clear limits of data-quality checks.
Working guide
Classify technical debt by the affected boundary and decision context, with practical distinctions among code, architecture, test, delivery, and knowledge debt.
Working guide
Write useful unit tests with explicit business assertions, focused fixtures, boundary inputs, controlled dependencies, and readable failure messages.
Working guide
Learn why regression testing is a purpose and unit testing is a boundary, with examples for bug fixes, fixtures, and selecting regression checks.
Working guide
Compare unit and component tests by what they render, which dependencies remain real, and how they verify logic, interaction, and visible behavior.
Working guide
Understand how unit and functional testing overlap, with practical examples of business requirements, isolated checks, and complete user outcomes.
Working guide
Compare unit and integration testing with concrete examples of isolated rules, real dependencies, setup costs, and the failures each layer detects.
Working guide
Use AI to draft test scenarios and automation code while checking expected behavior, data boundaries, failure detection, and review evidence.
Working guide
Understand Cypress unit and component testing boundaries, including direct function assertions, mounted components, command timing, and controlled requests.
Working guide
Apply the Strangler Fig pattern with a routing boundary, explicit data authority, contract checks, reversible cutovers, and an owned retirement plan.
Working guide
Structure µnit C tests with MunitResult functions, registered suites, typed assertions, fixtures, and compiler checks that keep failures easy to diagnose.
Working guide
Review the security risks of a prompt-driven prototype workflow, including public endpoints, permissive defaults, hidden secrets, and unclear ownership.
Working guide
Understand codeless test automation, including recorded steps, explicit assertions, reusable data, maintenance boundaries, and escape paths.
Working guide
Understand what AI-generated code is, where it helps, and how to review its dependencies, behavior, and ownership before using it in an application.
Working guide
Learn how a bug fix moves from a reproducible failure to a focused patch, regression checks, and a release decision that addresses the original defect.
Working guide
Understand unit tests through inputs, expected outputs, dependency boundaries, and a practical example that separates logic from integration behavior.
Working guide
Understand behavior-preserving code refactoring, when it helps, how it differs from rewriting, and what checks make structural improvements reviewable.
Working guide
Understand legacy code through change risk, missing knowledge, and unsupported dependencies, then decide what to preserve, test, refactor, or replace.
Working guide
Understand legacy modernization options, from targeted upgrades to incremental replacement, and connect each change to a concrete business constraint.
Working guide
Understand software maintenance as changes to delivered software, with practical examples of corrective, adaptive, perfective, and preventive work.
Working guide
Understand technical debt as future change cost, distinguish it from defects and missing features, and use concrete evidence to decide when to address it.
Working guide
Learn what test automation checks, where it fits in software delivery, and how to choose useful tests without replacing human exploration.
Working guide
Understand vibe coding as a prompt-driven software workflow, where it helps prototypes, and which behavior, ownership, and security checks remain necessary.
Working guide
Test Flutter application logic with Dart test functions, explicit matchers, controlled async dependencies, and a clear boundary from widget and device tests.
Working guide
Use Go's testing package for focused unit tests, table-driven boundary cases, subtests, small dependency seams, and reliable cleanup of changed state.
Working guide
Use JUnit for Java unit tests with focused assertions, parameterized boundary cases, clear setup, controlled collaborators, and normal build execution.
Working guide
Use node:test and strict assertions for Node.js unit checks, controlled dependencies, temporary resources, asynchronous outcomes, and clear test boundaries.
Working guide
Plan Playwright test automation with resilient locators, web-first assertions, isolated state, useful fixtures, and traces for failed journeys.
Working guide
Write Python unit tests for clear behavior with pytest assertions, parameterized boundaries, focused fixtures, and dependency patches at the correct seam.