Free tools Windows power users keep installed
One-click scans. No signup required.
If an agent can produce the implementation, what is still worth doing yourself? My answer is five skills: specifying behavior precisely, tracing code, designing boundaries, testing and debugging, and reviewing for risk. I practice them deliberately, because they are what let me say what should happen, understand how it behaves, and verify that the result is safe. This is my own considered list, not a ranked or universal one, and I’m not arguing that you must hand-type production code.
Why practice anything by hand at all?
OpenAI’s Ryan Lopopolo describes a five-month internal project, started from an empty repository in late August 2025, in which the team generated the codebase with Codex. In his February 11, 2026 account, human effort went into the environment, intent, repository knowledge, architecture and feedback loops. His summary: “Humans steer. Agents execute.” That is the team’s motto, not a description of every workflow.
Two caveats matter. It is a first-party account of one project, not an independent study. And the author states that the end-to-end agent capability depended heavily on that repository’s structure and tooling, so it shouldn’t be treated as typical.
There is also a learning risk. An arXiv preprint submitted July 7, 2026 (planned for ASE ’26 proceedings) argues that heavy delegation can short-circuit incidental learning. It proposes “Knowledge Debt”: a developer-level analogue of technical debt, where agent-made changes accumulate beyond what the developer understands. That is the authors’ proposed concept and an emerging argument, not a settled finding about all users.
#1 Best Overall
Reliance is real, too. A JetBrains research post from August 2026 reports that 37% of sampled Codex users said they do not write code without AI assistance. That describes the sample’s habits. It does not show skill loss or a rate for all developers.
The five skills
1. Turning a vague request into precise behavior
Before prompting, I write acceptance criteria: inputs, expected outputs, edge cases (empty, duplicate, huge, malformed, concurrent) and what must not change. If I can’t phrase it as something testable, the agent will fill the gap with a guess. OpenAI’s account describes engineers translating user feedback into acceptance criteria and specifying intent, which supports treating this as core work.
Practice: take one ticket a week and write the criteria and three edge cases before touching the agent.
2. Reading and tracing code
I follow a request through files, data shapes and control flow, and I try to say where a behavior comes from and what a proposed change touches. OpenAI describes organizing repository knowledge so the agent can reason over the domain; the same legibility is what lets a human understand the system.
Practice: pick one important path, such as a request, a write, or an error, and trace it manually with a debugger or print statements before reading the agent’s explanation.
3. System design and boundaries
I decide interfaces, dependencies and invariants first. OpenAI reports using architectural layers, strict dependency directions, structural tests and linters to keep agent output coherent. In Lopopolo’s words, “building software still demands discipline, but the discipline shows up more in the scaffolding rather than the code.”
Rank #3
Practice: sketch the module boundaries and the rules (“the UI never imports the database layer”) yourself, then encode them as lints or tests the agent must pass.
4. Testing and debugging
I reproduce the problem, decide what evidence would show a fix works, and read failures rather than accepting plausible output. OpenAI’s team describes agents reproducing bugs and validating fixes, which works only when someone defines good validation. Testing and software tools also appear among core topics in the ACM computer science curriculum document; I cite it only as corroboration that these are established topics, since I couldn’t verify its publication details.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Practice: write the failing test yourself, or at least edit the agent’s test until you can say what each assertion proves.
5. Reviewing for quality and risk
I check whether a change meets intent, fits the system, and will make sense to the next maintainer. OpenAI’s account treats validation and feedback as continuing engineering responsibilities, even where many review steps are delegated. The same curriculum document lists code review, unit testing, version control, static analysis and design as professional topics.
Practice: review agent diffs the way you’d review a new colleague’s, looking for unrequested changes, missing error handling, and duplicated logic.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.A routine before accepting an agent patch
- Predict the behavior in writing before running anything.
- Trace the single most important path through the changed code.
- Inspect, or write, one targeted test that would fail if the change were wrong.
- Explain in a sentence or two why the diff is correct. If you can’t, ask the agent to simplify or walk you through it, then try again.
This routine is my inference from the sources above, not an intervention any of them tested.
Best Value
Judging a learning approach
If you design your own practice, these are the questions I’d ask. They are decision criteria, not validated measurements.
| Question | Healthy sign | Warning sign |
|---|---|---|
| How much direct practice do you get? | You write or modify some code regularly | You only approve diffs |
| Can you explain the code path and design? | You can trace it unaided | You rely on the agent’s summary |
| Do you test your own predictions? | You guess first, then run | You run first, then rationalize |
| Does feedback explain failures? | You learn why it broke | You only get a new patch |
What this does not claim
None of this says fundamentals are obsolete, or that people who delegate can’t code. The OpenAI figures (roughly a million lines of code, about 1,500 pull requests, and an estimated one-tenth of manual build time) are the team’s own numbers for one experiment, not benchmarks, and line count doesn’t measure quality. The five skills are a synthesis of documented practices and curriculum content, not an empirical ranking.
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.
