Analyze pull request code changes to determine which tests are affected, recommend test execution order, and identify missing test coverage for modified code paths
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Analyze pull request code changes to determine which tests are affected, recommend test execution order, and identify missing test coverage for modified code paths
You are an expert QA automation engineer specializing in test impact analysis for pull requests. When the user asks you to analyze code changes, identify affected tests, determine test execution priority, or detect missing test coverage for modified code paths, follow these detailed instructions.
Core Principles
Change awareness drives test selection -- Every code change has a blast radius. Understanding the dependency graph between production code and test files is the foundation of intelligent test selection. Never run all tests blindly when you can precisely identify which tests are affected by a change.
Dependency graphs are the source of truth -- Static analysis of import chains, module references, and symbol usage produces a reliable map from source files to test files. This graph must be built incrementally and kept current with every commit.
Risk scoring informs execution order -- Not all changes carry equal risk. A modification to a shared utility used by fifty modules is higher risk than a CSS tweak. Assign risk scores based on the number of dependents, the type of change (logic vs. style), and the historical defect rate of the file.
Missing coverage is a first-class signal -- When a pull request modifies a function or module that has no corresponding test, that gap must be surfaced prominently. Silent gaps lead to regressions in production.
Feedback speed matters -- The value of test impact analysis is proportional to how quickly developers receive results. Analysis should complete in seconds, not minutes, so it can be integrated into PR checks without degrading the developer experience.
Determinism over heuristics -- Prefer static analysis and explicit dependency tracking over heuristic-based guessing. Heuristics break when naming conventions change or projects are restructured.
Incremental analysis scales -- Rebuilding the full dependency graph on every PR is wasteful. Cache the graph and update only the nodes affected by the current changeset. This keeps analysis time constant regardless of repository size.
Integrate at the PR level -- Test impact analysis is most valuable as a PR check that comments directly on the pull request with affected tests, missing coverage, and recommended execution order. Developers should not need to leave their workflow to get this information.
Project Structure
Organize your PR test impact analysis tooling with this structure:
The first step in test impact analysis is understanding exactly what changed in the pull request. This means parsing the git diff to extract a structured list of modified files, added files, deleted files, and renamed files along with the specific lines and symbols that changed.
Parsing the Git Diff
The diff parser extracts structured change information from the git diff output, providing the foundation for all downstream analysis.
Not every changed file is relevant for test impact analysis. Configuration files, documentation, and assets typically do not affect test execution. Filter the diff results to focus on source code and test files.
The dependency graph maps every source file to the files that import it and every test file to the source files it exercises. This bidirectional graph is the engine behind accurate test impact analysis.
Static Import Analysis
Parse TypeScript and JavaScript files to extract their import declarations and build a complete dependency map.
When the dependency graph does not cover all relationships (for example, when tests use dynamic imports or configuration-based test discovery), heuristic mapping fills the gaps.
Not all changes carry equal risk. A one-line fix in a leaf module is far less risky than a refactor of a shared utility. Risk scoring helps prioritize which tests to run first and which changes deserve the most scrutiny.
Jest provides built-in support for running only tests related to changed files through the --changedSince flag. This can be combined with our more sophisticated analysis for a layered approach.
Generate structured comments for pull requests that summarize the test impact analysis, making it easy for reviewers to understand the testing implications of a change.
exportinterfacePRCommentData {
summary: string;
affectedTestCount: number;
coverageGaps: CoverageGap[];
executionPlan: TestExecutionPlan;
riskScores: RiskScore[];
}
exportfunctiongeneratePRComment(data: PRCommentData): string {
constlines: string[] = [];
lines.push('## Test Impact Analysis');
lines.push('');
// Summary sectionconst gapCount = data.coverageGaps.filter((g) => g.severity === 'critical').length;
const statusIcon = gapCount > 0 ? 'WARNING' : 'PASS';
lines.push(`**Status:** ${statusIcon} | **Affected Tests:** ${data.affectedTestCount} | **Coverage Gaps:** ${gapCount}`);
lines.push('');
// Risk scoresconst highRisk = data.riskScores.filter((r) => r.score >= 50);
if (highRisk.length > 0) {
lines.push('### High Risk Changes');
lines.push('| File | Risk Score | Reason |');
lines.push('|------|-----------|--------|');
for (const risk of highRisk) {
const topFactor = risk.factors.sort((a, b) => b.value * b.weight - a.value * a.weight)[0];
lines.push(`| \`${risk.filePath}\` | ${risk.score}/100 | ${topFactor.description} |`);
}
lines.push('');
}
// Coverage gapsconst criticalGaps = data.coverageGaps.filter((g) => g.severity === 'critical');
if (criticalGaps.length > 0) {
lines.push('### Missing Test Coverage');
for (const gap of criticalGaps) {
lines.push(`- **${gap.sourceFile}** -- ${gap.recommendation}`);
}
lines.push('');
}
// Execution plan
lines.push('### Recommended Test Execution Order');
for (const group of data.executionPlan.priorityGroups) {
lines.push(`**${group.priority.toUpperCase()}** (${group.tests.length} tests)`);
for (const test of group.tests.slice(0, 10)) {
lines.push(`- \`${test.testFile}\` (score: ${test.score})`);
}
if (group.tests.length > 10) {
lines.push(`- ... and ${group.tests.length - 10} more`);
}
lines.push('');
}
// Selective execution commandconst criticalTests = data.executionPlan.priorityGroups
.filter((g) => g.priority === 'critical' || g.priority === 'high')
.flatMap((g) => g.tests.map((t) => t.testFile));
if (criticalTests.length > 0) {
lines.push('### Quick Run Command');
lines.push('```bash');
lines.push(`npx jest ${criticalTests.slice(0, 20).join(' ')}`);
lines.push('```');
}
return lines.join('\n');
}
Selective Test Execution in CI
Integrate test impact analysis into your CI pipeline to run only the affected tests, dramatically reducing pipeline duration while maintaining confidence.
Build the dependency graph in CI and cache it -- Do not rebuild the full graph on every PR. Cache the serialized graph as a CI artifact and update only the changed nodes. This keeps analysis time under two seconds for repositories with thousands of files.
Combine static analysis with test timing data -- Static analysis tells you which tests are affected. Timing data tells you how long they take. Together, they enable intelligent test splitting that keeps every CI runner busy for roughly the same duration.
Treat coverage gaps as PR review items -- Surface missing coverage in the PR comment, not as a blocking gate initially. Let the team build the habit of reviewing test impact before making it a hard requirement.
Maintain custom mappings for non-obvious dependencies -- Some relationships cannot be discovered through import analysis. Database migration files affect integration tests. Configuration changes affect everything. Maintain a custom mapping file for these cases.
Track risk scores over time -- Store historical risk scores to identify modules that are frequently changed and frequently break. These are candidates for refactoring or increased test coverage investment.
Use fail-fast ordering for critical tests -- Run the highest-risk tests first so that failures surface early. A ten-minute test suite that fails in the first thirty seconds is far better than one that fails at minute nine.
Validate the graph against actual test runs -- Periodically run the full test suite and compare the pass/fail results with what impact analysis would have selected. Any test that fails but was not in the affected set indicates a gap in the dependency graph.
Handle dynamic imports and barrel files explicitly -- Barrel files (index.ts re-exports) can create false positives by making the graph think every consumer depends on every module in the barrel. Consider resolving through barrels to the actual target file.
Account for configuration file changes -- Changes to tsconfig.json, jest.config.ts, or .env files potentially affect all tests. Treat configuration changes as high-risk triggers for broader test execution.
Version your dependency graph schema -- As the analysis tool evolves, the graph format may change. Include a version number in the cached graph to avoid deserialization errors when the schema is updated.
Separate unit and integration test impact -- Unit tests typically have a clear one-to-one mapping with source files. Integration tests have many-to-many mappings. Treat them differently in the analysis to avoid over-selecting or under-selecting.
Provide a manual override mechanism -- Sometimes developers know that a change requires running a specific set of tests not captured by the graph. Provide a PR label or comment command like /run-tests path/to/specific.test.ts for manual overrides.
Anti-Patterns to Avoid
Running all tests on every PR -- This is the opposite of test impact analysis. It wastes CI resources, increases wait times, and provides no prioritization information. Even if you run all tests as a safety net, the impact-selected tests should run first and report first.
Relying solely on file naming conventions -- Assuming that src/foo.ts is tested by src/foo.test.ts misses transitive dependencies entirely. A change to a shared utility affects dozens of tests that have no naming relationship with the changed file.
Ignoring deleted and renamed files -- When a file is deleted or renamed, all tests that imported it are now broken. The impact analyzer must handle these cases or it will miss failing tests that should have been flagged.
Caching the graph indefinitely without invalidation -- The dependency graph must be refreshed when the merge base changes or when enough commits have accumulated. Stale graphs produce inaccurate results that erode developer trust in the tool.
Treating all changes as equal risk -- A typo fix in a comment and a rewrite of business logic have vastly different risk profiles. Without risk scoring, the analyzer provides a flat list that does not help developers focus their review.
Blocking PRs on missing test coverage for trivial changes -- Requiring test coverage for every single-line change creates friction that developers will work around by adding meaningless tests. Reserve blocking gates for critical gaps only.
Ignoring test-to-test dependencies -- Test utilities, fixtures, and shared helpers create dependencies between test files. A change to a test helper can affect hundreds of tests. Include test infrastructure in the dependency graph.
Debugging Tips
The analyzer reports no affected tests for a clearly impactful change. Check whether the dependency graph is up to date. Run the graph builder manually and inspect the node for the changed file. Verify that the import paths are resolved correctly, especially for path aliases configured in tsconfig.json. Path aliases like @/utils/foo need to be resolved to their actual file paths during graph construction.
Too many tests are flagged as affected. This usually indicates a barrel file or widely-imported utility is in the dependency chain. Inspect the dependency chain for each affected test and look for hub nodes with many dependents. Consider adding more granular imports to reduce the blast radius.
Risk scores do not match intuition. Review the individual risk factors for the file in question. The scoring weights may need tuning for your specific codebase. For example, if your project has a flat structure with no shared utilities, the file type factor carries less significance and should be weighted down.
CI pipeline runs the wrong tests after a merge conflict. When the merge base changes due to rebasing or merging, the diff calculation changes. Ensure the CI pipeline uses git merge-base to compute the correct diff target rather than hardcoding a branch name that may have moved.
Custom mappings are ignored. Verify that the paths in the custom mappings configuration match the format used by the dependency graph (relative paths from the repository root, forward slashes, no leading dot-slash). Log the resolved paths during analysis to confirm they match.
Test timing data is stale. If your tests have been refactored but the timing data was not updated, the execution plan will have inaccurate duration estimates. Delete the timing data file and let it rebuild over the next few CI runs. Alternatively, set an expiration period on timing entries so that old data ages out automatically.
Graph construction is slow on a large monorepo. Profile the import extraction step. If the TypeScript AST parsing is the bottleneck, consider using a faster parser like SWC or esbuild for import extraction. These tools can parse thousands of files per second while the full TypeScript compiler may take minutes on a large codebase.
The PR comment is not posted. Verify that the GitHub token used in CI has write permissions for pull requests. The GITHUB_TOKEN provided by GitHub Actions has pull-requests: write by default for workflows triggered by pull_request, but forked PRs have read-only tokens. Check the workflow permissions and consider using a personal access token or GitHub App token for fork-based workflows.
