🤖 AI

From Junior to Senior: Allocating Agency and Navigating Professional Growth in Agentic AI-Mediated Software Engineering

Through a mixed-methods study comparing junior and senior software engineers, this paper reveals that organizational policies, rather than individual preferences, primarily constrain agency in AI-mediated development, highlighting how experienced developers leverage foundational instincts to effectively delegate and mentor novices who struggle with balancing reliance and caution.

Original authors: Dana Feng, Bhada Yun, April Yi Wang

Published 2026-04-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Dana Feng, Bhada Yun, April Yi Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the world of software engineering as a massive, bustling construction site. For decades, the way people built things followed a clear path: Juniors were the apprentices, learning the ropes by hammering nails and mixing concrete under the watchful eyes of Seniors, the master architects who knew exactly how the building would stand up to a storm.

Then, Agentic AI arrived. Think of AI not just as a fancy calculator, but as a super-fast, hyper-energetic robot assistant that can actually pick up the hammer, mix the concrete, and even design the blueprints if you ask it nicely.

This paper asks a big question: When you have a robot doing the heavy lifting, who is actually in charge? Does the robot become the boss, or does the human stay in the driver's seat? And how does this change the way apprentices learn to become masters?

Here is the story of their findings, broken down simply.

1. The Two Types of Builders

The researchers looked at two groups of builders:

The Juniors (The AI-Natives): These are the new hires who started their careers with the robot assistant. They've never known a world without it. To them, the robot is like a smartphone—just a normal part of life.
The Seniors (The Adapters): These are the veterans who learned to build before the robot existed. They have "gut instincts" built from years of making mistakes and fixing them. Now, they have to learn how to manage this new, powerful tool without letting it take over.

2. The "Rules of the Road" (Company Policies)

Before anyone even touches the robot, the Company sets the rules.

The Analogy: Imagine a construction site where the owner says, "You can use the robot, but only for painting walls, never for pouring the foundation."
The Finding: It doesn't matter if a Junior or Senior wants to use the robot for everything; the company's security policies and tools decide the boundaries first. The robot is only allowed to drive in certain lanes.

3. How They Drive: Familiar vs. Unfamiliar Terrain

The researchers watched how these builders used the robot in two different scenarios:

Scenario A: The Familiar Neighborhood (Easy Tasks)

Seniors: They treat the robot like a very fast intern. They give it very specific, tiny instructions ("Paint this one wall blue"). They check the work immediately. They stay in control because they know exactly what the finished wall should look like.
Juniors: They are also careful, but they are scared. They double-check everything the robot does because they aren't 100% sure if the robot is right. They treat the robot like a "spell-checker" rather than a "writer."

Scenario B: The Unknown Jungle (Hard, New Tasks)

Seniors: When they hit a wall they don't understand, they use the robot as a mapmaker. They ask, "Show me the path," or "What are the pros and cons of this route?" They use the robot to generate ideas, but they make the final decision. They know when to say, "No, that path leads to a cliff."
Juniors: This is where things get tricky. Without a strong mental map of the jungle, some Juniors let the robot drive the car. They get excited, press the "do everything" button, and suddenly the robot is making huge changes they don't understand.
- The Danger: They feel like imposters. They think, "I built this, but I didn't really do anything. The robot did it." They feel like frauds because they don't understand the code the robot wrote.

4. The Mentorship Crisis: Who Teaches Whom?

In the old days, the Senior taught the Junior by pointing at a blueprint and saying, "See how this beam holds the roof? That's why we do it this way."

Now, the robot can answer "How do I fix this bug?" instantly.

The Problem: If the Junior asks the robot, the robot gives an answer. But the Junior doesn't know why that answer is right. They miss out on the "aha!" moment of figuring it out themselves.
The Senior's New Role: Seniors realized they can't just answer questions anymore (the robot does that). Instead, they have to become Socratic Guides. They need to ask the Junior: "Why did you ask the robot that? What do you think the answer should be? Does this make sense?"
The Goal: Seniors are trying to teach Juniors how to think, not just how to type. They want to make sure the Junior isn't just accepting the robot's answer blindly.

5. The Solution: "Prompt & Code Reviews" (PCRs)

The paper suggests a new way to keep everyone safe and learning. Imagine a diary that the Junior must keep.

The Old Way: Junior writes code -> Senior checks code.
The New Way (PCR): Junior writes code -> Junior writes a short note explaining what they asked the robot and why they thought that was a good idea -> Senior checks both the code and the note.

Why is this cool?
It forces the Junior to be the author of their own thinking. Even if the robot wrote the code, the Junior has to explain the logic. This stops them from being a passive passenger and forces them to stay in the driver's seat. It turns the robot from a "magic wand" back into a "tool."

The Big Takeaway

The paper concludes that AI is a powerful tool, but it's not a replacement for human judgment.

For Seniors: Your experience is your superpower. You know when the robot is lying or making a mistake. Keep steering the ship.
For Juniors: Don't let the robot do your thinking for you. It's okay to use it to go fast, but you must understand the road you're driving on.
For Everyone: We need to change how we learn. We can't just copy-paste answers anymore. We have to learn how to question, verify, and own the work, even when a robot helped us do it.

In short: The robot can build the house, but the human must still be the architect. If we forget that, we might end up with a beautiful house that collapses because no one understood how it was built.

1. Problem Statement

The integration of Agentic AI (autonomous systems that execute actions, e.g., Cursor, GitHub Copilot) into software engineering is reshaping the distribution of agency, decision authority, and professional growth. While generative AI produces content via prompts, agentic AI can independently modify codebases, raising critical questions about:

Agency Allocation: Who holds decision authority and accountability when AI agents perform tasks?
Professional Growth: How does the "AI-native" entry of junior engineers (who have never worked without AI) compare to senior engineers (who adapted mid-career) in terms of skill acquisition, intuition, and mentorship?
Risk of Deskilling: There is a fear that reliance on autonomous agents may erode critical thinking, system understanding, and the "tacit knowledge" required for complex debugging and architectural judgment.

The paper investigates these dynamics to determine if AI is merely a productivity tool or a fundamental disruptor of the software engineering talent pipeline.

2. Methodology

The authors conducted a three-phase mixed-methods study involving 20 professional software engineers (10 Juniors, 10 Seniors) across various industries (Big Tech, FinTech, HealthTech, etc.).

Phase 1: Senior Elicitation (ACTA & Delphi)
- Participants: 5 Senior Engineers (5+ years experience).
- Method: Semi-structured interviews using Applied Cognitive Task Analysis (ACTA) to elicit tacit knowledge and cognitive strategies in debugging.
- Consensus: A Delphi-inspired process was used to refine these insights into a realistic, high-complexity debugging task that would reveal the gap between junior and senior problem-solving.
Phase 2: Junior Task Execution
- Participants: 10 Junior Engineers (≤1 year experience).
- Task: A 30-minute debugging challenge on a React-based admin application containing three distinct, silent bugs (infinite loops, service worker routing, improper window.location usage).
- Tool: Participants used Cursor (an agentic AI IDE) in either "Agent Mode" (autonomous execution) or "Ask Mode" (interactive Q&A).
- Data Collection: Code artifacts, prompt histories, interaction logs, post-mortem reports, and reflective interviews.
Phase 3: Senior Review (Blind Audit)
- Participants: 5 different Senior Engineers.
- Task: Blind review of anonymized artifacts (code, prompt histories, post-mortems) from the juniors in Phase 2.
- Goal: To simulate real-world mentorship and code review, evaluating how AI records (prompts) reveal junior reasoning, competence, and areas of over-reliance.

Analysis: Thematic analysis using grounded theory coding, triangulating interview data with quantitative survey results (NASA-TLX, confidence scales) and qualitative artifact review.

3. Key Contributions

The paper contributes a nuanced framework for understanding human-AI collaboration in software engineering:

Agency is Pre-configured by Policy: Individual preferences are secondary to organizational constraints. Company policies (security, approved tools, data privacy) define the boundaries of agency before the engineer even begins coding.
Divergent Agency Patterns:
- Seniors: Maintain control through strategic delegation. They use AI for boilerplate, syntax, and low-level tasks but retain high-level design and verification. They leverage pre-AI "foundational instincts" to detect hallucinations and architectural flaws.
- Juniors: Oscillate between over-reliance (trusting agents in unfamiliar contexts) and defensive avoidance. They struggle with scope control, often accepting large, unreviewed diffs or failing to understand the "why" behind AI-generated code.
The "Imposter Syndrome" & Ownership Gap: Juniors report feelings of fraudulence when AI generates code they do not fully understand, leading to a loss of professional fulfillment. Seniors emphasize that "coding is the easiest part" and that true seniority lies in system thinking and judgment.
Prompt & Code Reviews (PCRs): A proposed new practice where juniors document and justify key prompts and interaction modes, allowing seniors to audit the reasoning process rather than just the final code.

4. Key Results

A. Agency Allocation (RQ1)

High Familiarity: Both groups constrain AI to small, targeted edits. Seniors use AI as a "designer-like" tool (iterative refinement), while juniors use it for verification and "boring" tasks (tests, formatting).
Low Familiarity:
- Seniors: Separate design from code generation. They use AI to generate diagrams, ask for pros/cons, and confirm mental models. They treat AI as a "rubber duck" or a "faster Google."
- Juniors: Often lose scope control. In unfamiliar codebases, they trust the agent over themselves, leading to "free-falling" into agent suggestions. Many reported a decrease in confidence in their ability to code without AI after the task.

B. Professional Growth (RQ2)

Seniors: View AI as a tool to accelerate learning but warn against "handing over expertise." They emphasize that juniors must still build mental models and intuition through trial-and-error.
Juniors: Gain speed and exposure but risk skill atrophy. They fear their "critical thinking muscle" is weakening. Many admitted to "copy-pasting" without understanding, leading to imposter syndrome.
The Shift: The definition of a "Senior" is shifting from "knowing syntax" to "knowing when not to delegate" and possessing the judgment to validate AI outputs.

C. Mentorship in the Age of AI (RQ3)

AI as a Mentor: Effective for basic questions, syntax, and patterns. It reduces the burden on seniors for trivial queries.
Human Mentorship: Remains indispensable for context, organizational nuance, and critical thinking. Seniors act as guardrails against AI hallucinations and bad architectural decisions.
The Gap: Juniors often lack the intuition to know what to ask or when an AI answer is wrong. Seniors noted that juniors are less likely to offer theories or hypotheses, relying instead on AI to provide the answer.

D. Prompt History as a Review Artifact (RQ4)

Seniors found that prompt histories provided a window into a junior's thinking process that code alone could not.
Red Flags: "Prompt spirals" (repeatedly asking the same question without reading answers), lack of context in prompts, and accepting large diffs without verification.
Green Flags: Using "Ask Mode" to understand code before switching to "Agent Mode," and using AI to verify hypotheses rather than generate solutions from scratch.

5. Significance and Recommendations

The paper argues that the traditional talent pipeline (Junior $\to$ Senior via gradual complexity) is disrupted by AI. To preserve a sustainable engineering workforce, the authors propose three evolving practices:

Preserving Individual Agency:
- Engineers must maintain interruptibility (stopping agents before they spiral).
- Adopt legible provenance (knowing the source of code).
- Enforce small, test-bounded diffs to ensure accountability.
Evolving the Mentorship Pipeline:
- Seniors must shift from "answering coding questions" to "Socratic guiding" (asking juniors why they chose a path).
- Mentorship should focus on developing judgment and intuition regarding when to trust AI and when to rely on human insight.
Implementing Prompt & Code Reviews (PCRs):
- A collaborative practice where juniors document key prompts and their rationale alongside code.
- This ensures that even if AI writes the code, the human remains the author of the reasoning, preserving ownership and critical thinking skills.

Conclusion:
Agentic AI is not just a productivity booster; it is a structural force changing how software engineers learn and grow. Without deliberate intervention (like PCRs and evolved mentorship), the industry risks creating a generation of engineers who can operate tools but lack the deep system understanding required to guide them. The goal is not to replace human judgment but to use AI to amplify it, ensuring that engineers remain the "responsible developers and managers" of the activity, as Peter Naur envisioned in 1985.