What You’ll Need
- The AI-generated code, plus the surrounding files or a small reproducible example.
- A clear description of the intended behavior and expected inputs and outputs.
- The language runtime, dependencies, and test commands used by the project.
- A way to run tests in a disposable branch, local environment, or sandbox.
- Access to the model or code-review tool you intend to use. Check its documentation before sharing private or sensitive code.
Step-by-Step
- Confirm what “Elephant Goldfish” refers to. Search the project, tool documentation, or source where you saw the term. Check the exact spelling and whether it names a model, a prompt, a benchmark, or an internal workflow. Do not assume it is a particular product or that it has code-review features. If you cannot verify the identity, use the rest of this guide as a general model-assisted review process rather than attributing it to that name.
- Define the behavior the code should have. Write down the task in concrete terms: valid inputs, expected results, boundary cases, error handling, and constraints. For example, instead of saying “check this function,” state what it should return for an empty list, duplicate values, and invalid input. The model needs a reference for correctness; without one, it may flag intentional choices or approve plausible-looking but wrong code.
- Prepare a focused review package. Include the generated code and only the context required to understand it: related function signatures, types, relevant configuration, and existing tests. Remove credentials, access tokens, customer data, and other secrets. If the tool processes submitted code externally, follow your organization’s data-handling rules and the tool’s privacy documentation.
- Ask for specific, evidence-based findings. Request that the model identify reproducible defects, explain why each is a defect, point to the exact line or behavior, and suggest a minimal fix. Ask it to separate confirmed issues from questions or assumptions, and to consider edge cases, incorrect assumptions, unsafe input handling, and compatibility with the stated language and dependencies. Do not ask only “Is this code good?”—that encourages broad, low-value commentary.
- Supply tests and expected behavior. Share existing test results or ask for additional test cases that follow from your requirements. For each suspected problem, have the model describe an input that exposes it and the expected versus actual result. Treat generated tests as proposals: review the assertions yourself, since a test can repeat the same mistaken assumption as the code.
- Check every finding against the source. Read the cited lines and reproduce the issue with a minimal test or a debugger. Check whether the model misunderstood the surrounding code, language rules, library version, or intended behavior. A confident explanation is not proof. Mark findings as confirmed, not reproducible, or uncertain, and retain the input and test case that support your decision.
- Run independent checks. Use the project’s normal test suite and, when available, a formatter, compiler, type checker, linter, or security scanner. Run checks in an isolated environment and use the project’s documented commands. These tools catch different classes of mistakes; passing tests does not prove correctness, and a model’s review does not replace them.
- Apply changes in small steps. Make only fixes you understand, preferably one issue at a time. Re-run the targeted test and the broader relevant checks after each change. Review the final diff to ensure a suggested fix did not alter unrelated behavior, weaken validation, expose data, or introduce a new dependency without a reason.
- Record what remains uncertain. Note unverified assumptions, skipped checks, and issues that depend on production data or a specific environment. If the code affects a critical system, route it through the project’s normal human review and release process rather than relying on a model’s approval.
Common Mistakes
- Treating the model name as verified. “Elephant Goldfish” may be a typo, private project, or informal label. Confirm the source before claiming that a particular model performs a specific kind of review.
- Providing too little context. A single snippet without requirements, types, or dependency details can lead to incorrect findings. Supply the smallest useful context, not the entire codebase by default.
- Accepting suggested fixes without testing. A patch can silence a failing test while breaking a different case. Reproduce the defect, test the fix, and inspect the change.
- Confusing style feedback with defects. Formatting preferences and refactoring ideas are not necessarily bugs. Prioritize issues that violate requirements, fail at runtime, or create a clear reliability or security concern.
- Sharing secrets or sensitive code. Remove secrets and follow applicable data rules before using an external service. Do not paste private material simply because a tool requests more context.
- Relying on one review method. Models may miss defects or invent them. Combine model feedback with tests, static checks, and human judgment.
Tips
- Ask for findings in a consistent format: severity, location, conditions to reproduce, impact, and a minimal proposed correction.
- Request a review without a rewrite first. Reviewing the original makes it easier to distinguish actual defects from changes introduced by a broad rewrite.
- Give the model the language and dependency versions when behavior depends on them; otherwise, ask it to state assumptions.
- Ask it to list areas it could not assess, rather than treating silence as evidence that those areas are safe.
- Keep a human-readable test case for each confirmed defect. It makes the correction easier to review and guards against regression.
Troubleshooting
The model returns generic advice: Narrow the request to one function or behavior. Provide an expected result and ask for a concrete failing input, not a broad quality assessment.
It reports a problem you cannot reproduce: Check assumptions about runtime, dependency versions, input shape, and environment. Ask for a minimal reproduction, then label the claim unconfirmed until it can be demonstrated or explained from the relevant specification.
It misses an obvious bug: Add a focused test for that case and ask a new, narrow question. Try another independent review method, but do not assume that repeated model reviews guarantee completeness.
The proposed patch fails tests: Revert or revise the patch, identify which expected behavior changed, and work from a minimal failing test. Avoid applying a large generated rewrite before understanding its effects.
The tool cannot see required files or run the project: Provide the relevant interface and configuration excerpts, or run the project’s tests locally and share only the non-sensitive error output. Do not claim a review was executed if the tool only inspected text.
Frequently Asked Questions
Is Elephant Goldfish a known code-review model?
The name alone is not enough to identify a broadly established model or standard. Verify the exact tool and its documentation before relying on tool-specific features.
Can a model prove that AI-generated code is correct?
No. It can suggest likely defects, but correctness depends on requirements, execution, tests, and review of the surrounding system.
What should I include in a code-review prompt?
Include the relevant code, intended behavior, important constraints, and environment details. Ask for evidence and reproducible examples for each claimed defect.
Should I let the model edit the code automatically?
Use suggestions as drafts. Review each change and run relevant checks before accepting it, especially when the code handles important data or operations.
Can I upload proprietary code?
Only if your organization permits it and the tool’s data handling is suitable. Remove secrets and sensitive data, and use an approved environment when required.
What if the model finds no mistakes?
That means only that it found none in that review. Run tests and independent checks, examine edge cases, and follow the project’s normal review process.
Related