{
  "@context": "https://schema.org",
  "@type": [
    "NewsArticle",
    "TechArticle"
  ],
  "id": "ed_when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first",
  "canonicalUrl": "https://pseedr.com/devtools/when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first",
  "alternateFormats": {
    "markdown": "https://pseedr.com/devtools/when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first.md",
    "json": "https://pseedr.com/devtools/when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first.json"
  },
  "title": "When Coding Agents Write the First Draft, What Should a New Engineer Do First?",
  "subtitle": "Two software firms kept hiring early-career engineers and made a reviewed change the newcomer must explain and defend their first real work. Learning research suggests why the explanation step matters more than the reviewer title.",
  "category": "devtools",
  "datePublished": "2026-11-17T17:07:51.485702+00:00",
  "dateModified": "2026-11-17T17:07:51.485702+00:00",
  "author": "PSEEDR",
  "tags": [],
  "readTimeMinutes": 16,
  "wordCount": 3324,
  "contentTier": "free",
  "isAccessibleForFree": true,
  "editorialFormat": "analysis",
  "qualityFlags": [],
  "sourceCount": 7,
  "newsQualityEligible": true,
  "sourceUrls": [
    "https://www.youtube.com/watch?v=kspZP5BgkEU",
    "https://digitaleconomy.stanford.edu/app/uploads/2026/08/Canaries_August2026.pdf",
    "https://diginomica.com/ibms-chro-preaches-fluent-ai-jobs-blasphemy-heres-why-its-critical-business-leaders-everywhere-pay",
    "https://www.pymnts.com/artificial-intelligence-2/2026/ibm-to-triple-entry-level-hiring-as-ai-rewrites-junior-roles/",
    "https://www.anthropic.com/research/AI-assistance-coding-skills",
    "https://arxiv.org/abs/2405.17739",
    "https://www.mertdemirer.com/Papers/Demirer_AI_productivity.pdf"
  ],
  "contentHtml": "<p><em>Two software firms kept hiring early-career engineers and built their first work around a reviewed change the newcomer must explain and defend. Early learning research suggests a condition: reviewing agent output builds understanding when the engineer has to produce their own explanation, not when the tool supplies it.</em></p>\n<section aria-label=\"Companion video\" style=\"margin:1.5rem 0 2rem\"><h2>Watch the full analysis (14:21)</h2><div style=\"position:relative;width:100%;aspect-ratio:16/9\"><iframe src=\"https://www.youtube.com/embed/TwG8RP4ob-Y\" title=\"Coding Agents Write the First Draft. What Should a New Engineer Do First?\" style=\"position:absolute;width:100%;height:100%;border:0\" loading=\"lazy\" referrerpolicy=\"strict-origin-when-cross-origin\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen></iframe></div><p><a href=\"https://www.youtube.com/watch?v=TwG8RP4ob-Y\">Watch the full analysis (14:21) on YouTube</a> · <a href=\"https://www.youtube.com/shorts/6Jlr6UJJdCQ\">Watch the Short (0:57)</a></p><p>Join the discussion: <a href=\"https://www.linkedin.com/feed/update/urn:li:share:7528507543145484288\">LinkedIn</a> · <a href=\"https://x.com/PSEEDR/status/2122740809690988996\">X</a></p></section>\n\n<p>In a conference talk <a href=\"https://www.youtube.com/watch?v=kspZP5BgkEU\">published on YouTube on October 24, 2026</a>, Laurie Voss, head of developer relations at Arize AI and a co-founder of npm Inc., described the way junior developers used to be trained. In Voss’s words, “we used to give them very well-specified tickets that said, ‘Write this software this way in particular and then give it to me so that I can tell you all the ways that you were wrong.’” That loop, Voss argued, “is gone,” because “that’s what we do with the coding agents now.”</p>\n<p>Voss was making an argument, not reporting a study, and Voss works for a company that sells AI evaluation tools, an affiliation acknowledged in the talk. Still, the point is one an engineering manager can check against their own team. The well-specified ticket did two jobs. It delivered a small, bounded piece of work, and it taught the person who wrote it how the codebase and the team’s standards worked. When an agent takes over the first job, nothing guarantees that the second still happens.</p>\n<p>A manager whose team now hands much of its implementation to agents has three broad choices: pause early-career hiring, keep the old ticket-based path, or keep hiring and change what a new engineer does first. Voss’s own answer was that teams will have to grow juniors “on purpose.” That leaves a practical question. When an agent writes much of the code, what should a new engineer’s first work be, and what shows they are ready for more?</p>\n<p>Two firms’ written accounts and the learning research available so far point to an answer. Keep the path, and make the first deliverable a small, reviewed change that the new engineer can explain in their own words and attack with a failure case. That answer carries a condition, and the condition matters more than any new job title.</p>\n<h2 id=\"what-the-hiring-data-shows-and-what-it-cannot-tell-you\">What the hiring data shows, and what it cannot tell you</h2>\n<p>Voss illustrated the stakes with a chart of employment for engineers aged 22 to 25 and said, “Their employment is collapsing.” Voss told the audience the citations were on the slides, and the chart’s source cannot be confirmed from the talk itself.</p>\n<p>The main primary evidence on this pattern is the <a href=\"https://digitaleconomy.stanford.edu/app/uploads/2026/08/Canaries_August2026.pdf\">“Canaries in the Coal Mine?” paper</a> by Erik Brynjolfsson, Bharat Chandar and Ruyu Chen at the Stanford Digital Economy Lab. Its August 2026 version uses ADP payroll records for a panel of firms with 3.5 million to 5 million employees a month, through June 2026. The authors report that employment of workers aged 22 to 25 in AI-exposed occupations “now stands 19% below where it would be had it kept pace with that of their less-exposed peers; experienced workers show no comparable gap.” Software developers are among the occupations in the most exposed group.</p>\n<p>Two details sharpen what that means for a hiring manager. First, the gap “operates primarily through reduced hiring of young workers rather than increased separations.” Young people already in jobs were not pushed out faster; fewer were brought in. Second, the picture is narrower than “collapse.” In the authors’ sample, total employment for 22-to-25-year-olds was roughly flat from November 2022 to June 2026, a 1.9% decline. The divergence is concentrated in the most exposed occupations, especially where AI use substitutes for human tasks rather than complementing workers.</p>\n<p>The authors offer an interpretation that maps closely onto Voss’s ticket. AI, they write, “may be automating the checkable, process-intensive tasks that historically justified entry-level headcount.”</p>\n<p>The paper is also clear about what it does not show. “We caution that this work does not estimate a causal impact of AI,” the authors write. The pattern weakens when they control for the education level of occupations: in their primary sample, the estimated decline for the most exposed young workers roughly halves. The authors note that education may be a channel through which AI works rather than a separate cause. Some divergent trends predate generative AI. The gap is larger in the ADP sample than in national survey data, and the sample includes few firms with fewer than 10 employees.</p>\n<p>For a reader running a small or mid-size team, the useful conclusion is limited but real. In this large payroll sample, the entry-level squeeze runs through hiring decisions, and hiring is the lever a manager actually holds. The data cannot tell any single team why its peers stopped hiring juniors, or whether stopping was wise.</p>\n<p>At least one large employer said publicly that it was moving the other way. In February 2026, IBM’s chief human resources officer, Nickle LaMoreaux, spoke at Charter’s Leading With AI Summit in New York. <a href=\"https://diginomica.com/ibms-chro-preaches-fluent-ai-jobs-blasphemy-heres-why-its-critical-business-leaders-everywhere-pay\">As reported by diginomica</a>, she said, “We are tripling our entry level hiring, and yes, that is for software developers.” Voss described IBM’s redesign as built around customers and specs “instead of programming.” LaMoreaux’s own description was different: “They still do some coding. It’s with the assistance of AI. They still do testing.” <a href=\"https://www.pymnts.com/artificial-intelligence-2/2026/ibm-to-triple-entry-level-hiring-as-ai-rewrites-junior-roles/\">PYMNTS, citing Bloomberg</a>, reported that IBM overhauled its entry-level job descriptions and that junior developers there now spend less time on routine coding and more time with customers. IBM did not disclose hiring numbers, and an announcement is not an outcome. It does show one large employer openly choosing to keep hiring and change the role.</p>\n<h2 id=\"two-firms-kept-hiring-and-put-a-reviewed-change-first\">Two firms kept hiring and put a reviewed change first</h2>\n<p>What does early-career work look like in teams that kept hiring? Two leaders of software service firms described their versions in written responses to PSEEDR.</p>\n<p>Evgeny Leonov, Chief Technology Officer of <a href=\"https://ronasit.com\" rel=\"nofollow\">Ronas IT</a>, a software development company whose services include AI agent development, separates hiring from onboarding. On hiring, Leonov wrote: “We now judge an engineering candidate on what they can deliver with AI and whether they can verify the result.” The company’s assessment, according to Leonov, “asks candidates to apply AI to real work, check its output, and configure an autonomous pipeline for that kind of task.” The response does not say when that assessment began.</p>\n<p>On development, Leonov describes continuity rather than a break. “We’ve kept a practical development path for new backend engineers. Since autumn 2024, they’ve started on an internal training project.” New backend engineers read the team’s documentation, start the project with the company’s initializer and create entities with its generator. Then they take a feature through a merge request and review before they join client work. “Newcomers reach client projects having already practiced with the internal tools, and we’ve found that they get up to speed there sooner,” Leonov wrote, without giving a measurement behind that comparison.</p>\n<p>Amit Agrawal, Founder and COO of <a href=\"https://www.developers.dev\" rel=\"nofollow\">Developers.dev</a>, an outsourcing and staff augmentation firm, describes a sharper turn. “We moved our junior engineers from code producers to code editors the moment agents began handling the bulk of our implementation work,” Agrawal wrote. Rather than pausing junior hiring, the firm overhauled the first ninety days of a new engineer’s tenure “to treat the coding agent as the junior and the human engineer as the reviewer.” In practice, “A new hire’s first task is no longer writing functions from scratch, but auditing agent output against specific security and performance standards.” The response gives no date for the change.</p>\n<p>The two setups differ in ways that matter to a reader choosing between them. Leonov’s new engineers practice in an internal project before they touch client code. Leonov describes that path as kept rather than as a response to agents, and the change tied to AI in that account is the hiring screen. Agrawal changed the first task itself: new engineers start by auditing agent output against specific security and performance standards. What the two share is the shape of the first unit of work. In both firms, it is a change that passes through review and that the new engineer must answer for, not a ticket judged mainly by whether it got done.</p>\n<p>Both accounts are self-reports. Leonov’s “get up to speed there sooner” is a judgment, not a measurement. So are Agrawal’s statements that the shift “accelerated our delivery pipelines” and that “our early-career engineers are becoming system thinkers much earlier than previous cohorts.” Neither gave measured results. Both contributors are senior leaders at firms that sell engineering work, which gives them an interest in presenting their junior engineers as capable. Two firms are not a trend. Their value here is that they describe the design in enough detail to test it against what is known about how people learn with AI tools.</p>\n<h2 id=\"why-make-them-reviewers-is-not-enough-on-its-own\">Why “make them reviewers” is not enough on its own</h2>\n<p>The obvious version of the changed role turns the junior into a reviewer: the agent writes, the new engineer checks. Agrawal names the risk of that move directly. The shift, Agrawal wrote, “initially created a risk of superficial learning where engineers completed tasks without understanding the underlying architecture.”</p>\n<p>The most direct controlled evidence on that risk comes from a <a href=\"https://www.anthropic.com/research/AI-assistance-coding-skills\">randomized trial that Anthropic published in January 2026</a>. Anthropic sells AI coding tools, which is worth keeping in mind, although the result does not flatter its product. The researchers recruited 52 mostly junior software engineers who had never used the Python library Trio. Each did a 35-minute task built on that library, with or without an AI assistant, and then took a quiz. The AI group averaged 50% on the quiz and the hand-coding group 67%. The largest gap was on debugging questions. The AI group finished about two minutes faster on average, a difference that was not statistically significant.</p>\n<p>The averages hide the more useful finding: how participants used the assistant tracked closely with how much they understood. Some participants delegated the code, slid gradually into delegation, or relied on the assistant to debug and verify their work. Those groups scored under 40% on average. Other participants asked conceptual questions, asked for explanations along with generated code, or generated code and then asked follow-up questions to check their own understanding. Those groups scored 65% or higher. The researchers note that the generate-then-comprehend approach “looked nearly the same as that of the AI delegation group, except for the fact that they used AI to check their own understanding.”</p>\n<p>That detail explains how a reviewer role can fail. One of the lowest-scoring patterns, iterative AI debugging, resembles an easy trap for a review-first junior: asking the tool to check work the tool produced. The person is nominally reviewing, but the understanding stays with the assistant. Within the AI group, the higher-scoring patterns had one thing in common: the participant built their own model of what the code did, rather than leaving that model to the assistant.</p>\n<p>The trial has firm limits. The sample was small, and each usage pattern covered only two to seven people, so the authors do not claim that the patterns caused the outcomes. The quiz measured understanding shortly after one session, not long-term skill. And the setup used a chat assistant, not an agent. On that last point the researchers add that for agentic coding products, “we expect that the impacts of such programs on skill development are likely to be more pronounced than the results here.”</p>\n<p>Earlier classroom research points the same way. In <a href=\"https://arxiv.org/abs/2405.17739\">a 2024 study of 21 novice programmers</a>, James Prather and colleagues observed a divide between students who accelerated with generative AI tools and students who struggled, and reported that struggling students “finished with an illusion of competence.” The participants were students, not working engineers. But the study names the failure that a review-first onboarding has to guard against: a person who completes the work and believes they understand it.</p>\n<p>There is a real counterweight. Kevin Zheyuan Cui, Mert Demirer and colleagues analyzed <a href=\"https://www.mertdemirer.com/Papers/Demirer_AI_productivity.pdf\">field experiments with 4,867 developers</a> at Microsoft, Accenture and an anonymous Fortune 100 company, where access to GitHub Copilot was assigned at random. Among developers who adopted the tool, completed tasks rose by 26.08% (standard error 10.3%), and “less experienced developers had higher adoption rates and greater productivity gains.” That weakens the case for pausing junior hiring on usefulness grounds. The authors call the subgroup evidence suggestive, but in their data, newer and more junior developers appeared to gain the most. Still, the tool was the 2022–2023 autocomplete version of Copilot, not an agent, and the outcome was task counts, not learning. The authors themselves note that if developers rely on the tool without review, it “could introduce errors or decrease code quality.” Nothing in these studies rules out a new engineer producing more and understanding less at the same time.</p>\n<p>Taken together, these studies narrow the design question. A reviewer role is more likely to teach when the new engineer has to produce something that comes from their own understanding of the change. The two firms’ practices require that kind of output, though neither response cited research for it. Agrawal requires “every agent-assisted pull request to be accompanied by a manual architectural breakdown,” and adds: “The engineer must explain the logic as if they had authored every line.” Leonov’s standard is that “an early-career engineer has to defend the change, find a failure case, and know which behavior the team is accepting.” In PSEEDR’s reading, those requirements push a new engineer toward the generate-then-comprehend pattern and away from delegation, because the engineer cannot meet them by forwarding the agent’s own summary.</p>\n<h2 id=\"readiness-means-catching-the-wrong-assumption\">Readiness means catching the wrong assumption</h2>\n<p>If the first deliverable changes, the readiness signal has to change with it. Voss put the underlying shift this way: “the cost of producing plausible code has collapsed while the cost of knowing whether to trust that code has stayed exactly the same.” Speed is a weak signal when an agent can produce a plausible change faster than any person. Both firms moved the test to judgment instead.</p>\n<p>Leonov names the failure to catch: “A quick implementation can carry a wrong assumption into production. I want the engineer to catch that assumption before review, explain the behavior of the change, and take responsibility for what gets merged.” Agrawal judges readiness “by a candidate’s ability to spot logic hallucinations or inefficient database queries that an automated tool might overlook.”</p>\n<p>Drawn only from those two accounts, the observable signs of readiness are these. The new engineer:</p>\n<ul>\n<li>names the assumption a change depends on, and says whether it holds, before a reviewer has to;</li>\n<li>explains the behavior of the change in their own words, including the parts the agent wrote;</li>\n<li>produces at least one concrete failure case for the change;</li>\n<li>states which behavior the team is accepting by merging it;</li>\n<li>spots invented logic, or an inefficient database query, that an automated tool missed.</li>\n</ul>\n<p>None of these is a score, and neither firm described a rubric. They are things a senior reviewer can see in a pull request and its explanation. They also line up with where the Anthropic trial found its largest gap, debugging. And they connect to Agrawal’s warning that if juniors never take apart what the agent builds, the result is “technical debt that will come due during complex, non-standard troubleshooting.” Leonov’s own sentence is the closest thing to a definition: “Readiness shows up in the engineer’s judgment over a delivered, reviewed change.”</p>\n<h2 id=\"comparing-the-three-choices\">Comparing the three choices</h2>\n<table>\n<colgroup>\n<col style=\"width: 25%\" />\n<col style=\"width: 25%\" />\n<col style=\"width: 25%\" />\n<col style=\"width: 25%\" />\n</colgroup>\n<thead>\n<tr>\n<th>Choice</th>\n<th>Who in this material made it</th>\n<th>What supports it</th>\n<th>What it risks or leaves unknown</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Pause junior hiring</td>\n<td>No firsthand case here. The Stanford data show the aggregate adjustment running through reduced hiring</td>\n<td>Short-run cost savings</td>\n<td>LaMoreaux’s pipeline argument: no future mid-level engineers. Cui et al. found suggestive evidence that juniors gained the most output. The Stanford data are descriptive and cannot say whether pausing was wise.</td>\n</tr>\n<tr>\n<td>Keep the old ticket path unchanged</td>\n<td>No case in this material</td>\n<td>Nothing here shows the old path fails to teach. The Anthropic trial suggests that hand-writing built more immediate understanding</td>\n<td>Voss argues the well-specified ticket may no longer exist to hand out now that agents take it. No evidence on how this path compares over time.</td>\n</tr>\n<tr>\n<td>Keep hiring and make the first deliverable a reviewed change the junior must explain and defend</td>\n<td>Ronas IT (training project ending in a merge request and review; AI-verification hiring screen), Developers.dev (audit-first 90 days with an architectural breakdown). IBM announced a related change, a rewritten role, but not this specific design</td>\n<td>In the Anthropic trial, explanation-seeking use of AI went with more understanding. The readiness signal moves to caught assumptions</td>\n<td>Heavier senior review load. Superficial learning if the explanation step is skipped. No measured outcomes from either firm.</td>\n</tr>\n</tbody>\n</table>\n<h2 id=\"what-it-costs-and-when-it-fits\">What it costs, and when it fits</h2>\n<p>The changed path is not free. Agrawal is direct about who pays: “this model increases the burden on senior leads who must now guard against over-reliance on automation.” Someone has to read the architectural breakdowns, test the failure cases and decide whether the explanation actually matches the code. Neither firm put a number on that time, and none of the sources here measured it.</p>\n<p>From the two accounts and the research, PSEEDR infers three conditions that make a review-first path more likely to work as training rather than as cheap review labor:</p>\n<ul>\n<li>Seniors have time set aside to examine the new engineer’s explanation, not only the diff.</li>\n<li>The standards the junior audits against are written down. Agrawal’s version names specific security and performance standards. Without written standards, review has nothing to check against.</li>\n<li>There is a low-stakes place to practice before client or production work, like Leonov’s internal training project.</li>\n</ul>\n<p>Where those conditions are missing, the review step can drift toward the delegation patterns that scored worst in the Anthropic trial, and toward the illusion of competence that Prather’s team observed.</p>\n<p>Pausing has its own cost, paid later. LaMoreaux framed it as a question that HR leaders should put to their executives: “Where am I going to get a middle manager three or four years from now?” Her point was that hiring those people from competitors costs more and brings in people who do not know the organization. That is an argument, not a measurement. But because the Stanford data show the adjustment running through hiring, the pipeline is the part of the decision a team controls.</p>\n<h2 id=\"the-answer\">The answer</h2>\n<p>Keep the early-career path, and make its first deliverable a small, reviewed change, written by an agent or by hand, that the new engineer must explain in their own words, attack with at least one failure case, and defend in terms of the behavior the team is accepting. Do this first somewhere the stakes are low. Judge readiness by whether the engineer catches the wrong assumption before a reviewer does, not by how fast the change appeared.</p>\n<p>The condition carries the weight. Putting a junior in front of agent output does not teach them anything by itself. Requiring them to produce their own model of that output can. The evidence for this is mainly one small, short-term trial with a chat assistant, a classroom study of novices, and two firms’ unmeasured accounts. That makes it the best-supported design in the material reviewed here, not a proven one.</p>\n<p>One question stays open across everything reviewed here: how much senior review time a review-first onboarding actually costs per new engineer, and when it pays back compared with the old ticket path. Neither firm measured it, and no study here did either. Teams that track that cost will learn more about whether this path scales than any of the current accounts can show.</p>\n",
  "articleImage": {
    "url": "https://storage.googleapis.com/pseedr-content/assets/article-covers/when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first.903cfd35.png",
    "width": 1280,
    "height": 720,
    "alt": "A mechanical arm holds a printed sheet of code while a person writes notes in a notebook, under the headline Juniors Must Explain the Change."
  },
  "image": {
    "@type": "ImageObject",
    "url": "https://storage.googleapis.com/pseedr-content/assets/article-covers/when-coding-agents-write-the-first-draft-what-should-a-new-engineer-do-first.903cfd35.png",
    "width": 1280,
    "height": 720,
    "alt": "A mechanical arm holds a printed sheet of code while a person writes notes in a notebook, under the headline Juniors Must Explain the Change."
  }
}
