Using AI to Generate Code? Prove It Works or Risk Losing Your Job

AI makes code production cheap, but value lies in proven work

AI coding assistants (e.g., Claude Code, Cursor, Copilot) can turn a brief requirement into a functional module within minutes, reducing the raw cost of code output.

The engineer’s responsibility is to deliver code that has been personally verified to work.

Example of responsibility shift

A developer generates a payment‑module implementation with AI, sees tidy code, and submits a pull request. The reviewer discovers:

Missing input validation

Empty exception handling

No edge‑case coverage

The code has never been executed

The reviewer spends hours diagnosing and fixing the issues, effectively performing the developer’s validation work.

Two indispensable steps to prove code works

Step 1 — Manual testing

The engineer must observe the code run in the intended environment, confirming:

Happy‑path behavior

Edge‑case handling

Error‑path handling

Evidence (command‑line output, screenshots, recordings, logs) should be attached to the pull request.

Step 2 — Automated testing

Automated tests follow the same logical flow:

Set up the initial state

Execute the code

Assert that results match expectations

Gold‑standard validation: delete the implementation and verify that the test fails, proving the test actually covers the change.

Warning: Automated tests must not replace manual verification.

AI coding agents do not transfer responsibility

In 2025, agents such as Claude Code can write code, execute it, self‑test, detect errors, fix them, and re‑test.

Human engineers must still ensure the agent proves the code works before accepting it.

Specific actions:

Require the agent to run the CLI tool and validate its behavior.

Require the agent to capture screenshots (e.g., CSS visual changes).

Require the agent to generate accompanying test cases, not just business logic.

The ultimate accountability remains with the human.

Team pull‑request submission rules (directly usable)

Rule 1 — Only submit code that has been proven effective

Do not submit AI‑generated code or large patches without self‑testing.

Do not offload verification to reviewers.

Before submitting, ensure:

Code runs locally.

Both normal flow and at least two edge/exception scenarios are verified.

Verification evidence (output, screenshots, recordings, logs) is attached to the PR description.

Rule 2 — Combine manual testing and automated testing

Manual testing: engineer personally confirms functionality.

Automated testing: include test cases that cover the change, fail when the code is removed, and follow the project’s test style.

Prohibit doing only one of the two.

Rule 3 — When using an AI coding agent

Require the agent to run the code, self‑test, report errors, and fix them before the engineer reviews.

Require the agent to generate matching test cases.

The final responsibility stays with the human.

Pull‑request self‑checklist (AI era)

Do not submit without self‑testing; attach verification evidence. Perform both manual testing and automated testing; neither may be omitted. If using AI, the AI must validate first; the human remains accountable.

Concrete checklist template

## PR self‑checklist (all items must be checked)
- [ ] Manual testing passed (happy path + edge cases)
- [ ] Verification evidence attached (screenshots / logs / recordings)
- [ ] Automated test(s) added/updated
- [ ] Test proves code effectiveness (fails when code is rolled back)
- [ ] AI‑generated code self‑tested, fully understood, and owned by me
- [ ] No debug statements, no sensitive information
- [ ] Conforms to project conventions

I confirm: I am submitting **code that has been proven to work**.

Final observation

AI lowers the barrier to writing code, but it cannot eliminate the engineer’s duty to take responsibility for the code’s correctness and reliability.