From Code-Centric to Intent-Centric Software Engineering: A Reflexive Thematic Analysis of Generative AI, Agentic Systems, and Engineering Accountability
This paper employs a reflexive thematic analysis of diverse technical and academic sources to argue that generative AI and agentic systems are transforming software engineering from a code-centric practice to an intent-centric discipline, where human accountability shifts toward supervising, validating, and governing socio-technical systems to mitigate risks like hidden technical debt and accountability gaps.
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
The Big Idea: From "Writing the Script" to "Directing the Play"
Imagine software engineering used to be like a playwright sitting alone in a room, writing every single line of a play by hand. That was the old way: Code-Centric. The engineer's main job was typing out the exact words (code) that the computer needed to understand.
This paper argues that we are moving to a new era called Intent-Centric. Now, imagine the engineer is no longer the playwright, but the Director.
The Director doesn't write every line of dialogue. Instead, they tell a very talented, fast, but sometimes confused AI Assistant (the "Agent") what the scene needs to feel like, what the characters should do, and what the rules of the world are. The AI writes the first draft of the script. The Director's job is now to:
- Make sure the AI understood the vision (Intent).
- Check if the lines make sense and fit the story (Verification).
- Ensure the play doesn't break the theater's safety rules (Governance).
The paper claims that while AI makes it cheaper and faster to produce words (code), it makes the Director's job of guiding and checking those words much more important.
Key Concepts Explained with Analogies
1. The "Software 2.0" Shift (The Hybrid Artifact)
The Paper Says: Software is no longer just hand-written code; it's a mix of code, AI models, and prompts.
The Analogy: Think of building a house. In the past, you had to cut every brick and mix every bag of cement yourself. Now, you have a robot that can lay bricks instantly. But the house isn't just the bricks anymore; it's the bricks plus the robot's instructions, the blueprint the robot read, and the safety sensors on the robot. The "house" (the software) is now a hybrid of human design and machine execution.
2. The "Agentic Workflow" (The Loop, Not the Prompt)
The Paper Says: We are moving from single prompts to agents that plan, search, edit, test, and fix things in a loop.
The Analogy:
- Old Way (Single Prompt): You ask a chef, "Make me a sandwich." They hand you one sandwich. If it's burnt, you have to ask again.
- New Way (Agentic Workflow): You tell a sous-chef, "Make a sandwich for a party." The sous-chef goes to the fridge (searches context), grabs the bread (edits files), makes the sandwich, tastes it (runs tests), realizes the mustard is too spicy, swaps it out (repairs errors), and then puts it on a plate for you to approve (pull request). The AI is doing the whole loop, not just one step.
3. The Core Tension: Speed vs. Accountability
The Paper Says: The main conflict isn't Human vs. AI; it's Acceleration vs. Accountability.
The Analogy: Imagine a race car.
- Acceleration (The AI): The AI is the engine. It can go incredibly fast and produce a lot of "plausible code" (a car that looks like it drives).
- Accountability (The Human): The human is the driver and the safety inspector. If the car crashes because the AI didn't see a stop sign, who is responsible? The paper argues that if you just let the engine run wild (speed) without a driver watching the road (accountability), you will crash. The goal is Bounded Autonomy: letting the car drive itself, but only within a fenced track with a driver ready to hit the brakes.
4. The "Technical Debt" Trap
The Paper Says: AI lowers the cost of making code, but if we aren't careful, we create "hidden technical debt" (future problems).
The Analogy: AI is like a fast-food machine that can make a burger in 10 seconds. It's great for a quick lunch. But if you build a whole restaurant only on fast-food burgers without checking if the ingredients are fresh or if the kitchen is clean, you might get sick later. The "debt" is the bill you have to pay later to fix the mess the fast machine made. The paper warns that just because code is easy to make doesn't mean it's easy to keep safe forever.
5. The New Role of the Engineer
The Paper Says: Engineers are becoming "Architects, Verifiers, and Accountable Operators."
The Analogy:
- Before: The engineer was a Bricklayer. Their value was how many bricks they could lay perfectly.
- Now: The engineer is a Site Manager. The robot lays the bricks. The Site Manager's value is:
- Did the robot lay the bricks in the right spot? (Verification)
- Does this wall fit the overall building design? (Architecture)
- If the wall falls, is the Site Manager the one who has to explain why? (Accountability)
The "Maturity Pathway" (How we get there)
The paper suggests we are moving through five stages, like levels in a video game:
- Level 1 (Current): You have a "Copilot." It helps you write code, but you do everything. Risk: You trust it too much and miss mistakes.
- Level 2 (Near Future): Teams start setting rules. "The AI can write code, but a human must approve it." Risk: People use secret AI tools the company doesn't know about.
- Level 3 (Mid Future): Specialized AI agents handle specific jobs like testing or security. Humans and AI work together in a coordinated dance. Risk: The AI agents get confused and fight each other.
- Level 4 (Longer Future): The whole system is connected. The AI understands the business rules and the building design automatically. Risk: The AI follows the rules perfectly but misses the spirit of what the customer wanted.
- Level 5 (The Goal): "Bounded Autonomy." The AI handles routine, boring changes on its own, but humans step in for big, complex, or risky decisions.
What the Paper Does NOT Say
- It does not say engineers will lose their jobs. It says their job will change from "typing" to "managing and verifying."
- It does not say AI is perfect. It explicitly warns that AI can make mistakes, hallucinate (make things up), and create security holes.
- It does not predict a specific year when this will happen. It says the timeline depends on how fast companies learn to manage the risks.
The Bottom Line
The paper concludes that Generative AI makes creating software cheaper, but it makes managing software more expensive and important.
If companies just chase speed (Acceleration) without building strong safety nets (Accountability), they will build a house of cards that collapses later. The smart path is to use the AI's speed but keep a human in the loop to ensure the result is safe, secure, and actually solves the right problem.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.