Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Give an AI coding assistant a narrow behavior to change, a clear boundary around the work, and a verification command—and require it to inspect, plan, implement, test, and review in stages. This makes each change easier to understand and test than asking for a broad feature in one pass. It does not guarantee that the assistant will touch fewer files or produce correct code; the practical safeguard is to check the plan and complete diff at each checkpoint.
What makes an AI coding change small and testable?
A small change is not simply one that edits a low number of files. One behavior may legitimately require a production module, a test file, and a fixture. Conversely, a one-file rewrite can be difficult to review if it mixes unrelated cleanup with the requested behavior. Aim for the smallest coherent change that delivers one observable result and can be verified with a focused test.
As an Amazon Associate I earn from qualifying purchases.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →“Testable” means the expected behavior can be checked independently of the implementation. A test should express what the code must do, including relevant boundaries or errors, rather than repeat the implementation’s own logic to calculate what the answer ought to be. It should fit the repository’s existing test runner and conventions, and it should assert observable behavior without weakening expectations just to make a test pass.
The workflow is a sequence of controlled handoffs: learn the repository, agree on scope, plan when needed, implement one slice, run focused tests, inspect the diff, and repeat only if another slice is necessary. Each handoff gives you a chance to catch a wrong assumption before it spreads into more code.
How should I configure the assistant before it edits?
Start with an inspection-only request. Do not ask for implementation in the same message: first find the relevant code and learn how the project tests it.
- Ask for repository reconnaissance. Have the assistant identify the smallest relevant module, the test file that best matches existing conventions, the test framework, and the commands for running one focused test and the related suite.
- Make the no-edit boundary explicit. Say that the assistant must not modify files during this inspection. Ask it to report findings and uncertainty, not to infer a test setup from a familiar language or framework.
- Check the proposed locations and commands. Confirm that the module and test actually correspond to the behavior, and that the commands use the project’s existing runner. If the assistant cannot establish a command, resolve that before relying on its verification report.
- Run a baseline where appropriate. A pre-change test run helps distinguish an existing failure from a regression. Inspect the setup first, then run a relevant baseline rather than assuming every repository has the same commands or test layout.
This first stage prevents common scope mistakes: editing a similarly named but irrelevant module, adding tests in a new framework, or choosing a broad suite when a focused test is available. Repository research, planning, iterative changes, diff review, and pull-request creation are also distinct parts of the cloud-agent workflow described in GitHub’s Copilot documentation, rather than a reason to skip checkpoints.
Inspection prompt
Inspect the repository and its testing setup before editing. Identify the smallest relevant module, the existing test file that best matches its conventions, and the commands for one focused test and the related suite. Do not edit files yet. Report any uncertainty about the behavior or test setup.What should I include in the implementation request?
Name the behavior, point to the relevant code or a reproducible example, state constraints, and say how you will verify the result. This is more useful than a broad instruction such as “improve this module” because it gives the assistant both an intended outcome and a boundary around its solution.
- Goal: one observable behavior, described in terms of what a caller or user can see.
- Context: relevant file paths, reproduction steps, related tests, and existing helpers or fixtures to reuse.
- Constraints: interfaces or behavior to preserve, areas not to touch, and any project conventions that matter.
- Acceptance conditions: expected normal behavior, relevant boundary cases, and specified error behavior.
- Verification: the focused test command first, followed by the related suite if the focused check passes.
- Exclusions: no unrelated refactor, new dependency, test-framework change, or weakened assertion unless explicitly required.
OpenAI’s Codex prompting guidance makes the same core point: a useful request names the behavior, points to relevant code or reproduction steps, preserves important constraints, and explains how to verify the change. These details help narrow the assistant’s choices; they do not replace reviewing its work.
Behavior-first prompt
Goal: Change one observable behavior: <describe the expected result>.
Context:
- Relevant files or reproduction: <paths and steps>
- Existing conventions to follow: <framework, helpers, naming, and tests>
- Constraints: preserve <interfaces or behavior>; do not touch <unrelated areas>
Acceptance:
- <explicit expected result>
- <relevant boundary or error case>
Use the existing test framework. Do not add dependencies, refactor unrelated code, or weaken assertions. First inspect and report the relevant code and tests; do not edit yet.Replace each description with project-specific information before sending the prompt. If you do not know the file path, ask the assistant to identify likely locations during inspection, then confirm the choice before implementation. Avoid asking it to “make the tests pass” without stating the expected behavior: that instruction can reward changing an assertion rather than fixing the code.
When should I ask for a plan first?
For a straightforward, well-localized change, inspection followed by one implementation slice may be enough. Ask for a plan before editing when the work spans multiple files, has unresolved assumptions, or could affect interfaces or adjacent behavior.
A useful plan is short and reviewable. It should identify the files expected to change, the behavior change in each, the tests for normal and boundary behavior, and risks or assumptions that need resolution. Treat it as a proposal, not permission for the assistant to expand scope. If it lists unrelated cleanup, unnecessary new infrastructure, or tests that do not establish the requested behavior, revise the plan before coding begins.
Plan prompt
Propose a plan for this one behavior. List the files you expect to touch, the smallest implementation steps, tests for expected and boundary behavior, and any unresolved assumptions. Do not edit until the plan is approved.This checkpoint is most valuable when a task has dependencies between steps. For example, a test may need a fixture change as well as a production-code change. Seeing those proposed edits together lets you decide whether they are truly part of one coherent slice or whether the request should be split further. If an assumption cannot be answered from the repository or the stated requirements, resolve it rather than letting the assistant silently choose a behavior.
How do I keep implementation to one narrow slice?
Ask for the minimum coherent change that satisfies the approved behavior, then stop for verification. Do not bundle unrelated refactoring, style changes, or speculative improvements into the same pass; each additional behavior makes failures and review harder to localize.
A practical loop is red, green, refactor, review:
- Red: add or agree on one test that captures the expected behavior and, when relevant, demonstrates the current failure.
- Green: implement only what is needed to satisfy that test and the acceptance conditions.
- Refactor: improve the code only while keeping the relevant tests green and the requested scope intact.
- Review: inspect the diff and decide whether another distinct slice is necessary.
Ask the assistant to stop after the slice rather than autonomously continuing into adjacent work. That pause matters: if the test exposes a different problem, you can decide whether it belongs in the request or should be handled separately. Visual or language-level simplicity is not the only measure; a good slice gives a reviewer a clear explanation of why each changed file is necessary.
Rank #3
Implementation prompt
Implement only the approved slice for <one behavior>. Reuse the repository’s existing helpers, fixtures, framework, and naming conventions. Preserve the stated interfaces and constraints. Do not refactor unrelated code or add dependencies. Stop after this slice and report the files changed and the tests you added or updated; do not claim verification until you run the requested command.How should I ask for meaningful tests?
Specify the behavior the test must prove, not a particular implementation detail that could change without changing the contract. Ask for the normal case, relevant boundaries, and specified error behavior, using the existing test framework and project conventions.
Tests are easier to trust when their expected values come from the requirement, not from calling the implementation under test. For example, if the code transforms an input, avoid asking the test to derive its expected output by invoking the same transformation a second time. That can make the test agree with a defect. Prefer an explicit expected result or an independently established fixture.
Keep tests independent and focused. Reuse existing fixtures where they accurately represent the behavior, but do not make a test pass by deleting assertions, broadening expected outcomes, or changing unrelated tests. A test that only checks an internal detail may become brittle; where the requirement is about observable behavior, assert the result a caller can see.
Test-writing prompt
Add only the agreed tests using the existing framework. Cover the normal case, both relevant boundaries, and specified error behavior. Keep expected values explicit and independent of the implementation. Do not change production code or weaken assertions to make a failure pass.“Both relevant boundaries” means the limits that matter for this behavior, not an instruction to invent arbitrary edge cases. Use requirements and existing project behavior to choose them. If the request does not define how an edge case should behave, surface that as an unresolved question rather than encoding an assumption as a test.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsWhich tests should the assistant run, and what should it report?
Run the narrowest useful test selection first, then the related suite. The focused test gives quick feedback on the changed behavior; the broader related suite checks for regressions that the narrow test may miss.
- Run the focused command. Use the command discovered during inspection and target the test or module that covers the change.
- Review failures before editing further. Determine whether the failure is in the new test, the implementation, test setup, or an existing baseline issue.
- Expand after the focused check. If it passes, run the related suite to catch interactions with nearby behavior.
- Ask for an exact report. Require the command, pass count, fail count, skipped count, and a diagnosis of failures. The assistant should distinguish a test it ran from one it merely recommends.
Verification prompt
Run the focused test command now. Report the exact command, pass count, fail count, skipped count, and full failure diagnosis. Do not change implementation code or weaken assertions to make a failure pass. If the focused test passes, run the related suite and report it separately.Frequent focused runs shorten the feedback loop and make it easier to isolate a regression. They do not prove the change is correct in every environment, and a reported pass should not substitute for checking that the requested command actually ran against the relevant test. If a test fails, keep the failure visible while diagnosing it; silently changing code, expected values, and assertions together removes the evidence you need to decide what went wrong.
How do I review the diff before integrating the change?
Read the complete diff against the requested behavior and the approved plan. Check every changed file, not just the main implementation, and ask whether each edit is needed for this one behavior.
- Scope: Are there unexpected files, unrelated renames, formatting churn, or behavior changes outside the request?
- Tests: Do the tests cover the stated result and relevant boundaries? Are expected values independent, and are assertions still meaningful?
- Correctness: Are errors handled as required, and do edge cases follow the acceptance conditions?
- Security: Check input validation, injection risks, and accidental exposure of secrets where relevant to the changed code.
- Assumptions: Does the diff depend on a behavior or interface that was never established?
- Verification: Do the reported commands and results correspond to the tests you expect for this change?
Diff-review prompt
Review the current diff against the requested behavior and approved plan. List unintended changes, missing tests, error-handling concerns, security risks, and assumptions that still need confirmation. Do not broaden the scope.GitHub’s Copilot workflow treats diff review as a deliberate stage before pull-request creation. VS Code’s guidance likewise emphasizes reviewing generated code and tests, edge cases, security, and checkpoints before integration. A clean test run is useful evidence, but it cannot tell you whether the assistant changed an unrelated interface or introduced an unsafe input path.
Recommended Free Tools
What should I do when the assistant changes too much or tests fail?
Stop the current iteration and return to the last clear checkpoint. Diagnose scope or test failures before asking for another implementation pass; a larger follow-up request can make both problems harder to untangle.
If the diff is broader than agreed
- Identify the changed files and hunks that do not support the approved behavior.
- Ask the assistant to explain why each is needed, without authorizing more edits.
- Remove or revert unrelated work, then re-check the focused test and diff.
- If the behavior genuinely needs a second change, make it a separate slice with its own acceptance conditions.
If a test fails
- Capture the exact command and failure output, then establish whether the same failure existed in the baseline.
- Check that the test encodes the requirement and uses the intended fixtures and setup.
- Ask for a diagnosis before permitting code changes. Do not allow the assistant to weaken the assertion simply to obtain a pass.
- After a targeted correction, rerun the focused test, then the related suite if it passes.
If the assistant cannot identify the right behavior or test
Provide a concrete reproduction or clarify the acceptance condition. An assistant cannot safely infer product decisions, such as what an invalid input should return, from the existence of a function alone. Keep that uncertainty explicit until the desired behavior is agreed.
Best Value
How can I reuse this workflow in a single prompt?
A reusable prompt can describe the stages, but it should still require a pause before editing when the work spans multiple files. Keep the behavior and repository context specific to the task; a generic template is a scaffold, not a substitute for those facts.
Goal: <one observable behavior>
Context:
- Relevant files or reproduction: <paths and steps>
- Existing conventions to follow: <framework, helpers, naming, tests>
- Constraints: preserve <interfaces or behavior>; do not touch <unrelated areas>
Plan:
1. Inspect the relevant code and tests.
2. Propose the smallest implementation and test plan.
3. If the change spans multiple files, wait for plan approval before editing.
4. Implement one slice at a time.
5. Run <focused command>, then the related suite.
6. Report commands, pass/fail/skipped counts, failures, and remaining risks.
Acceptance:
- <explicit expected result>
- <boundary or error cases>
- Tests remain independent and assertions are not weakened.For a one-file change, the planning pause can be lightweight; for a multi-file change, keep approval explicit. The assistant should report what it inspected before editing, what it changed, what it ran, and any risks still unresolved. If it has not run a command, the report should say so rather than imply successful verification.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Does this workflow guarantee smaller or better code?
No. It improves control over scope and makes feedback and review more deliberate, but the official guidance behind this workflow does not establish a measured percentage reduction in code size or a benchmark showing that generated changes become more testable. Treat the process as a way to make work inspectable and testable, not as a quantitative guarantee.
The strongest practical signal is whether a reviewer can connect each changed file to the requested behavior, understand the test’s expected result, and reproduce the verification. If that chain breaks, reduce the scope, resolve the missing assumption, or split the work before proceeding.
Frequently Asked Questions
Should I let an AI coding assistant commit or open a pull request automatically?
Keep any integration or pull-request step behind your review checkpoint. A branch or pull request can package the work, but it does not replace confirming that the diff matches the requested behavior and that the reported tests ran.
What if the project has no tests for the code I need to change?
Ask the assistant to identify the existing test setup and conventions before proposing a new test location or framework. If the repository truly lacks a suitable test, agree on the smallest compatible way to verify the behavior instead of letting the assistant introduce a second testing system by default.
Can a smaller diff still contain a serious bug?
Yes. Diff size is a reviewability aid, not a correctness measure. Review behavior, error handling, security implications, and test quality even when only one file changed.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
