Agent-First Computing and the Fate of Beginner CLI Literacy

Core judgment

The strongest defensible conclusion from the current evidence is that natural language can plausibly replace the traditional beginner CLI as the primary entry interface for many novice programming workflows, but not as a complete substitute for the conceptual knowledge needed to supervise an autonomous coding agent. Modern coding agents already let users describe intent in plain language while the system explores a repository, edits files, runs local tools, proposes plans, and surfaces approvals, diffs, tests, and logs for review. OpenAI Codex CLI, GitHub Copilot CLI, GitHub Copilot cloud agent, and Claude Code all explicitly support this “describe the task, then supervise the agent” pattern. [1]

At the same time, the literature does not support the stronger claim that beginners can safely or durably succeed with only natural-language interaction and no operational understanding. Studies of novice programmers using code-generating AI repeatedly show a mixed picture: faster completion, less frustration, and sometimes no short-term retention penalty on near-transfer tasks, but also over-reliance, omissions in prompts, weak understanding of generated code, false confidence, and new verification burdens. That pattern implies that the scarce skill is shifting away from command production and toward delegation, verification, and recovery. In other words, the critical literacy is becoming less “How do I type the command?” and more “How do I tell the agent what to do, constrain it, inspect what it did, and catch it when it is wrong?” [2]

A good research paper could therefore defend the thesis that the real curricular transition is from command-line literacy to agent-supervision literacy. The most careful version of that thesis would say: beginners need much less memorized shell syntax than older curricula assumed, but they still need a compact mental model of files, processes, permissions, version control, risk boundaries, and failure recovery in order to supervise an autonomous agent well. That claim is not yet fully proven experimentally, but it is strongly motivated by converging evidence from coding-agent tooling, novice-programmer studies, human–AI delegation research, and AI security research. [3]

Why this question matters now

This topic matters because the interface layer has changed faster than curricula have. Introductory materials still commonly present the terminal as a prerequisite skill and teach beginners early command-line navigation, file manipulation, and shell conventions. MDN’s command-line course frames terminal usage as something web developers will “undoubtedly” need and lists foundational commands like cd, ls, mkdir, grep, mv, and cp. The Odin Project calls the command line a “critical skill” and “base of operations,” while Codecademy and MIT’s Missing Semester similarly treat shell fluency as core beginner infrastructure. [4]

But current tools are no longer mere autocomplete. OpenAI’s Codex CLI says users can start in a repository, describe a task, and let the agent explore code, plan a change, edit files, run tools, and review changes before shipping. GitHub now describes Copilot CLI as an autonomous coding agent that can plan multistep workflows, run tests, and operate with varying levels of human approval, while Copilot cloud agent can research a repository, create implementation plans, make code changes on a branch, and iterate before a pull request. Anthropic describes Claude Code as an agentic coding tool that reads the codebase, edits files, runs commands, and integrates with development tools across terminal, IDE, desktop, and browser surfaces. [5]

That combination creates a curricular mismatch. Traditional shell-first instruction assumes the learner must personally compose and execute commands from the start. Agent-first workflows invert that sequence: the learner states goals in natural language, the agent proposes or executes command-level actions, and the learner’s job becomes approval, review, correction, and recovery. The research significance is not merely pedagogical convenience. It is a deeper question about whether beginner competence is moving from syntax fluency to supervisory judgment. The longitudinal literature on AI coding assistants is already describing a broader work shift from creation toward verification and “supervisory engineering work,” suggesting this is not just a student issue but an emerging change in software practice more broadly. [6]

What the evidence says about beginners using AI for programming

The evidence for performance gains is real. In a controlled study of 69 novices aged 10–17, access to an AI code generator improved correctness and reduced time on code-authoring tasks, while immediate post-test and one-week retention results did not show evidence that the tool impeded learning on the measured tasks. The authors concluded that AI coding assistants can scaffold novice learning under those conditions. A separate controlled study of undergraduates doing brownfield programming tasks in an unfamiliar legacy codebase found that students completed tasks 35% faster and made 50% more solution progress with Copilot, while also spending less time manually writing code and less time searching the web. [7]

The evidence for learning and judgment risks is also real. Prather and colleagues’ lab study of novices using generative AI found that although 20 of 21 students completed the assigned task, struggling students’ prior metacognitive difficulties persisted and GenAI could compound them, creating illusions of competence and false beliefs about how well they had performed. A survey of 298 students in an introductory course found wide adoption of ChatGPT but highly variable use, ranging from uncritical acceptance of generated solutions to more critical engagement, leading the authors to argue for classroom guardrails and explicit instructional guidance. Another study of 231 students found most were using AI for programming tasks, but more frequent reported use was negatively correlated with course performance, which the authors interpret cautiously but treat as an educational warning sign. [8]

The evidence is especially striking when the task itself becomes natural-language programming. “Prompt Problems,” introduced as a programming exercise for the GenAI era, are designed to teach students to solve programming tasks by crafting natural-language prompts rather than directly writing code. A newer study of more than 900 CS1 students found that these tasks were generally perceived as easier and more enjoyable than traditional coding tasks and as better targeted toward problem-solving, but students’ most common mistakes were omissions of crucial details, suggesting over-reliance on the model to infer what the student had failed to specify. When prompts failed, students tended to clarify intent rather than inspect generated code or tests deeply. [9]

The broader literature now points to a durable pattern: AI can reduce friction on production tasks while simultaneously making comprehension, calibration, and verification more important. A recent systematic review of GenAI in programming education concludes that successful integration depends on intentional teaching strategies, structured assessment, and curriculum alignment; it also warns that over-reliance can diminish higher-order thinking and programming logic. A 2026 longitudinal study of professional developers similarly argues that AI coding assistants shift effort from code creation toward verification and trust calibration, creating what the authors call “supervisory engineering work.” [10]

The implication for your research question is subtle but important: the beginner may need less direct command execution skill than before, yet more skill in specifying, judging, and correcting mediated action. That is precisely why this is a serious research topic rather than a marketing slogan. [11]

What command-line knowledge beginners still need

If the question is “How much command-line knowledge does a beginner actually need when working with an autonomous coding agent?”, the most defensible answer is: less syntax, more systems understanding. The beginner likely does not need to memorize a wide shell vocabulary at the start, but does need a compact operational model robust enough to supervise the agent.

The minimum useful knowledge appears to be concentrated in a handful of concepts rather than a long command list:

• Workspace and filesystem model: what a repository is, what a current directory means, how files and folders relate, and why editing outside the workspace matters. Codex’s permission model distinguishes actions inside the working directory from edits outside it, and GitHub’s agent documentation similarly separates local and branch-based work contexts. [12]
• Execution lifecycle: the difference between installing dependencies, running a program, executing tests, and interpreting failures in logs or terminal output. All of the major current agents explicitly run commands and tests as part of their loop, so the user must at least recognize what stage the agent is in. [13]
• Permission and risk boundaries: when the agent is allowed to read, edit, or use the network; what approval prompts mean; and why automatic approval changes the risk surface. OpenAI, Anthropic, and GitHub all document approval or permission modes, and GitHub explicitly warns that --allow-all-tools gives Copilot access to run any shell commands the user can run. [14]
• Change inspection and rollback: how to review diffs, checkpoint work, and revert or isolate unwanted changes. Codex emphasizes review and Git checkpoints; Copilot cloud agent emphasizes diff review, branch-based changes, and pull requests. [15]
• Failure recovery: how to stop the agent, rerun tests, ask for a safer alternative, reset scope, and recover from a bad turn. This is increasingly central because current agents can continue iterating autonomously, including in reduced-interruption modes such as Codex Auto-review and Claude Code auto mode. [16]
• High-risk operation recognition: destroying files, moving outside the workspace, pulling arbitrary network content, executing install scripts, or exposing secrets. These are the places where prompt injection, data leakage, and tool misuse become practical supervision problems rather than abstract security topics. [17]

This is why “natural language replaces the CLI” is too crude. It may replace manual command composition for many beginners, but it does not replace the need to understand the semantic consequences of command execution. Natural language removes one burden—the need to remember exact syntax—but preserves, and in some ways amplifies, the need to understand what actions are safe, what outputs are trustworthy, and what should happen next. That interpretation is consistent with older natural-language programming research, which has long argued that natural language is closer to the problem domain but also inherently ambiguous, as well as with newer end-user programming work arguing that generative AI shifts attention away from learning formal syntax and toward control, agency, explanation, and debugging. [18]

There is also a deeper human-factors reason not to equate natural-language ease with novice competence. Human–AI delegation studies show that people are often poor delegators when they lack metaknowledge about their own capabilities and the AI’s strengths and weaknesses, and that contextual information can improve team performance. In programming education, a recent AIED 2026 study operationalized “appropriate reliance” as accepting correct AI suggestions and rejecting incorrect ones; higher trust was associated with lower appropriate reliance, meaning that trust often reduced discrimination rather than improving judgment. That is exactly the kind of failure mode an agent-first curriculum must target. [19]

A research design that could actually answer the question

A strong study would compare the three instructional models you proposed: traditional CLI-first, agent-only natural-language-first, and hybrid agent-first with minimal CLI concepts. The hybrid condition is especially important because the existing literature rarely compares total removal of command literacy against a deliberately compressed systems model; most current studies compare AI access versus no AI access, not competing curricular sequences. [20]

Experimental structure

The cleanest design would be a randomized controlled trial with beginners who have little or no prior shell experience. A practical population could be first-term university students, adult career-switchers, or nontechnical professionals in an enterprise upskilling program. Training duration should be long enough to avoid a toy result—something like several weeks rather than a single lab—because the literature repeatedly notes the need for longitudinal work and warns against overgeneralizing from short, narrow tasks. [21]

The task battery should cover more than “write a small program.” To test the real claim of agent-first computing, participants should complete authentic workflows such as environment setup, reading an unfamiliar repository, implementing a focused change, running tests, debugging a failure, recovering from an incorrect agent action, and handling a deliberately risky or privileged request. Brownfield tasks are especially valuable because existing evidence shows that AI can change novice performance in unfamiliar codebases, which is closer to real development than isolated exercises. [22]

Outcome measures that matter

The outcome set should combine productivity, learning, and safety rather than reducing the study to speed alone.

A compact but powerful measurement suite would include:

• Task completion and time to completion, because controlled studies already show AI-associated differences here and these are easy to compare across groups. [7]
• Appropriate reliance, operationalized behaviorally by seeding the agent with a mix of correct and incorrect actions or recommendations and measuring whether the participant accepts or rejects them appropriately. This directly adapts a recent education study’s reliance framework and is much better than simple satisfaction or self-reported trust. [23]
• Error recovery quality, including whether the participant notices a wrong turn, contains damage, and restores a correct state. This follows logically from the newer emphasis on supervisory work and trust calibration. [24]
• Security and boundary errors, such as unsafe approvals, misuse of secrets, or failure to recognize untrusted content. Because prompt injection and tool misuse are established risks for agents, ignoring this dimension would leave the study incomplete. [17]
• Delayed retention and transfer, including the ability to perform related tasks several weeks later, both with and without the agent. This addresses the gap between short-term scaffolding effects and durable competence. [25]
• Conceptual understanding, assessed through explanation tasks: what the agent did, why a test failed, what the approval prompt meant, and which files or commands were risky. Those explanation-style assessments are crucial because several studies find success despite weak understanding. [26]

Key hypotheses worth testing

A plausible hypothesis set would be:

The agent-only group will likely post the best early task-completion and fastest time on straightforward tasks, because that is where existing AI-assistance studies tend to show the biggest gains. [7]

The traditional CLI-first group may eventually show stronger manual independence, but at the cost of lower short-term access, steeper initial friction, and worse early productivity on authentic tasks. This is an inference from current curricula and from the fact that many beginner resources still front-load shell mechanics before higher-level automation. [27]

The hybrid agent-first group is the most likely winner on the combined objective: high early productivity and better medium-term judgment, recovery, and safety. That specific expectation is an inference, but it is supported by several strands of evidence: multi-layer interface design helps novices start simple and add complexity later; contextual information improves delegation decisions; and programming-education reviews increasingly recommend intentional, structured GenAI integration rather than unrestricted use. [28]

Why this design would be publishable

This study would be valuable because it targets a gap the literature has not resolved. Existing work has already shown that AI can help novices perform faster, and it has also documented harms such as over-reliance, prompt omissions, weak comprehension, and false confidence. What is missing is a direct comparison between competing pedagogical sequences: Should the terminal be taught first, or should the terminal be interpreted through an agentic workflow? Your design would answer exactly that. [29]

Curriculum and enterprise implications

If the research comes out the way current evidence suggests, the practical implication is not “stop teaching the terminal.” It is “stop teaching full terminal syntax as the first bottleneck.” A hybrid curriculum would treat the agent as the learner’s initial control surface and introduce CLI concepts gradually, only when they become necessary for supervision, debugging, or recovery. That structure aligns closely with Shneiderman’s older argument for multi-layer interface design: novices begin with a limited, safer layer, build confidence, and only later move into more complex features when needed. [30]

In education, this suggests a sequence such as: start with goal specification in natural language; teach approval prompts, diffs, and test results; introduce the filesystem and workspace model; then add a very small set of direct shell actions for inspection and recovery. That sequence is also consistent with newer educational interventions such as Prompt Problems and CodeAid, both of which recognize that the pedagogical target is no longer just code writing but also prompting, reflection, and guarded forms of assistance. CodeAid in particular was explicitly designed with guardrails to prevent students from simply requesting direct solutions, and instead uses scaffolding features to support understanding and debugging. [31]

In enterprise settings, the relevance is equally strong. Today’s agentic tools already operate under approval models, permission presets, branch-based review flows, and increasingly autonomous modes. That means onboarding cannot stop at “Here is the tool.” Workers need procedural habits for scoping tasks, approving only what matches the task, recognizing when untrusted content could manipulate an agent, and reviewing diffs and test outputs before acceptance. Vendor docs and security guidance from OpenAI, GitHub, Anthropic, OWASP, and Microsoft all point in the same direction: autonomy raises the premium on boundary awareness and disciplined supervision. [32]

That is why the phrase delegation literacy is not just clever branding. It accurately captures the emerging skill bundle: articulate intent, bound the workspace, control permissions, inspect diffs, validate tests, calibrate trust, and recover from bad actions. The literature on human–AI collaboration suggests that delegation quality depends on contextual understanding, calibrated trust, and support for human judgment, not just task offloading. In programming, recent work on “supervisory engineering work” suggests that those capacities are becoming part of the job itself. [33]

Bottom line for the proposed paper

The most persuasive thesis for a paper, course, or book chapter is this:

Natural language is now strong enough to replace the traditional beginner CLI as the first operational interface for many learners, but it does not eliminate the need for a beginner to understand the environment well enough to supervise an autonomous coding agent. What disappears is not the need for operational knowledge; what changes is the form of that knowledge. The beginner’s burden shifts away from memorizing commands and toward constrained delegation, verification, and recovery. [34]

That makes your proposed title—From Command-Line Literacy to Agent-Supervision Literacy—substantively strong, not just rhetorically attractive. It fits the current tool landscape, matches what the best novice-programming studies are already finding, and opens into a publishable empirical question with clear curricular and enterprise consequences. The claim is not that the CLI is dead. The claim is that for beginners working with autonomous agents, the CLI is no longer the main thing they must produce; it is increasingly the environment they must learn to interpret and govern. [35]

References

[1] [3] [12] [14] [32] Agent approvals & security | ChatGPT Learn

https://developers.openai.com/codex/agent-approvals-security

[2] [7] [20] [25] [29] Studying the effect of AI Code Generators on Supporting Novice Learners in Introductory Programming

https://arxiv.org/pdf/2302.07427

[4] [27] Command line crash course - Learn web development | MDN

https://developer.mozilla.org/en-US/docs/Learn_web_development/Getting_started/Environment_setup/Command_line

[5] [15] [35] Codex CLI | ChatGPT Learn

https://help.openai.com/en/articles/11096431-openai-codex-limits

[6] [24] The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study

https://arxiv.org/html/2605.23135v1

[8] The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers

https://juholeinonen.com/assets/pdf/prather2024widening.pdf

[9] [31] A New Programming Exercise for the Generative AI Era

https://dl.acm.org/doi/10.1145/3626252.3630909?utm_source=chatgpt.com

[10] Literature Review on the Integration of Generative AI in Programming Education | International Journal of Artificial Intelligence in Education | Springer Nature Link

https://link.springer.com/article/10.1007/s40593-025-00524-3

[11] Understanding Student Perceptions, Mistakes, and Debugging Approaches when Solving Natural Language Programming Tasks

https://arxiv.org/html/2607.05034v1

[13] [34] Codex CLI | ChatGPT Learn

https://developers.openai.com/codex/cli

[16] Auto-review of agent actions without synchronous human oversight

https://alignment.openai.com/auto-review/

[17] Understanding prompt injections: a frontier security challenge | OpenAI

https://openai.com/index/prompt-injections/

[18] faculty.ist.psu.edu

https://faculty.ist.psu.edu/wu/papers/n2p.pdf

[19] Cognitive Challenges in Human–Artificial Intelligence Collaboration: Investigating the Path Toward Productive Delegation | Information Systems Research

https://pubsonline.informs.org/doi/10.1287/isre.2021.1079

[21] Human-AI Experience in Integrated Development ...

https://arxiv.org/html/2503.06195v1?utm_source=chatgpt.com

[22] [26] The Effects of GitHub Copilot on Computing Students’ Programming Effectiveness, Efficiency, and Processes in Brownfield Programming Tasks

https://arxiv.org/html/2506.10051v1

[23] Trust and Reliance on AI in Education: AI Literacy and Need for Cognition as Moderators

https://arxiv.org/html/2604.01114v2

[28] [30] %!PS-Adobe-3.0

https://www.cs.umd.edu/users/ben/ACM-CUU2003.pdf

[33] Human Delegation Behavior in Human-AI Collaboration: The Effect of Contextual Information

https://arxiv.org/html/2401.04729v2

Related background: Top AI Coding Assistants: 2026 Update to the 2025 Agentic Coding Guide

Chinese companion: Agent 优先计算与初学者 CLI 素养的命运