Software Engineer

You're learning the craft in a world where the agent writes the code and the human writes the specs. The job is not what it was three years ago — and you are not learning to be the engineer who existed three years ago.

Elevationprimary Convergencesecondary Emergencepartial

Family

Engineering

Equivalent legacy role

Software Engineer, Junior/Mid Software Engineer, Mid-level Developer

Reports to

Engineering Manager or Tech Lead

Works alongside

Full-Stack Engineers · Tech Lead · Product Designer · Product Manager · DevOps Engineer

The work

You contribute to features on a team. The agent handles a large portion of the line-level code production; you handle the work the agent does badly, the work that requires judgment you're still building, and the work that the team's process expects of you at this tier. You're learning two crafts at once — the engineering itself, and the AI-native operating model that runs the engineering.

Day-to-day, you:

Implement features that have been specified. A Senior FSE or Tech Lead writes the spec; you collaborate with the agent on the implementation, validate the output against the spec, and bring the work to a merge-ready PR.
Write your own specs for smaller scope. Bug fixes, small enhancements, internal tooling — you specify first, agent implements, you validate. Specification practice starts early.
Read agent output critically. Even when the agent produces working code, you ask: is this how this codebase wants it written? Does it match the team's patterns? The reading is the apprenticeship.
Pair with the agent through clarification dialogues. Before the agent executes, it surfaces questions; you answer the ones you can, escalate the ones you can't.
Take feedback on your specs and your PRs. From Senior FSEs, Tech Leads, the agent reviewer. Each feedback item is a lesson; the team is investing in your craft.
Validate at risk-graded gates. Routine work flows through the agent reviewer with you as second-pair-of-eyes. Anything irreversible, customer-facing, or beyond your current tier escalates to a Senior FSE or Tech Lead.
Maintain context. Documentation, runbooks, the team's shared prompts and scenario libraries. Contributing to these is part of building your judgment.
Show up to recalibration sessions. When the agent stalls, the team convenes. You participate; you watch how senior engineers diagnose; the watching teaches you.

What success looks like

Concrete outputs at this tier:

Throughput growing. Stories you take end-to-end ship at predictable cadence. Your throughput grows quarter over quarter as your specifications get sharper.
PR quality. The agent reviewer flags fewer of your PRs over time. Senior engineer feedback compounds into independence.
Spec writing emergent. You're starting to write specs that an agent can execute end-to-end. Some still need senior pass; the proportion shifts toward self-sufficient over months.
Recalibration awareness. When a story stalls, you can articulate whether the issue is spec, context, or implementation. Even if you escalate, you bring a hypothesis.
Codebase intuition. You're starting to know which abstraction this codebase wants, which patterns to follow, what house style means. Taste is forming.

What does not count as success: lines of code written, PR count alone, hours logged, sticking to legacy junior-engineer metrics that don't translate to this operating model.

What makes this work interesting

You're learning the craft of engineering as it's being reinvented. That's rare and valuable.

You have no legacy habits to unlearn. Senior engineers transitioning to AI-native work have to give up muscle memory built over years. You don't. The specification-first, agent-collaborative way of working is your normal — that's an advantage, not a deficiency.

Your impact ramps faster. A junior engineer in the legacy world spent the first 6-12 months mostly producing simple code. At T2 in an AI-native team, you can specify and ship meaningful features within months. The feedback loop from your contribution to shipped value is much shorter.

The team is teaching you, intentionally. Specifications you receive are also teaching materials. PR feedback is structured. Recalibration sessions are public learning. The apprenticeship is real — and more visible than the trial-by-fire junior experience of the legacy era.

You build cross-stack early. With the agent absorbing what used to be deep specialty work (frontend layout, backend wiring, infrastructure config), you can contribute across the stack from early in your career. The breadth comes faster.

You're learning to think before you type. This is the most durable career skill in any era, and your role concentrates it. People who learn to specify well early outperform people who only build the skill later.

You see senior judgment up close. Spec dialogues, code reviews, recalibration sessions — these are the moments where senior engineers reveal how they think. The proximity is real apprenticeship.

What may not appeal. If you wanted the role for the experience of long focused coding sessions, producing functional code from scratch line by line, that work is largely absorbed. Junior engineers who got into the field because they love the act of coding sometimes find AI-native work less hands-on than they expected. Some develop the new craft and find it more satisfying than the old; some don't. The legacy junior-developer experience of slowly building craft through volume of code written is mostly gone. You build it through volume of specifications read, specifications written, and recalibrations witnessed.

Who thrives in this role

The aptitudes that matter most are learning, judgment-development, and writing aptitudes — and they apply earlier in your career than they used to.

You ask good questions. The skill that most predicts your growth at this tier is the quality of questions you ask — about specs, about codebases, about the agent's output, about your own draft work. People who pattern-match and stay silent learn slower than people who ask.

You read voraciously. Specs, PRs, codebases, agent output, the framework's standards. Engineering at T2+ is mostly a reading job; the writing follows from the reading.

You handle being a novice gracefully. You don't know everything; you're not supposed to. People who can hold that without performing certainty learn faster than people who pretend.

You write clearly. Specs, PR descriptions, design notes. Engineers who can write clearly at this tier rise faster than engineers who can't, regardless of code-cleverness.

You take feedback well. Senior engineers and the agent reviewer are both giving you feedback constantly. People who can absorb it without defensiveness compound much faster than people who get defensive.

You're curious about the agent's failure modes. Why did the agent get this wrong? Why did the spec miss this edge case? Why did the recalibration session change the outcome? Curiosity about the system is what makes you good at it.

You build patience with messy diagnosis. Recalibration vs debugging vs spec-gap is hard to distinguish even for seniors. You won't get it right early; you build the judgment over time.

Less essential than before: raw typing speed, depth in any one programming language, algorithm trivia, the ability to power through CRUD work for hours. These were the junior engineer's apprenticeship. They are no longer the differentiators.

Skills to develop to get there

The aptitudes describe disposition. The skills below are what you actively build.

Spec reading. Understanding what a spec is asking, what it isn't, and what's ambiguous. How to practice: before implementing any spec, write one paragraph summarizing what you'll build and what's still unclear. Compare to the spec author's intent.

Spec writing (starting small). Bug fixes, small enhancements, internal tooling — write the spec first. How to practice: for every task you take, draft a spec even if no one asked. Review with a Senior FSE; refine. Build the muscle.

Diff reading. Reading agent-produced code critically. How to practice: before approving any agent PR you took, articulate why each significant block is correct or incorrect. Track when you missed something; the pattern is your learning.

Clarification dialogue navigation. Answering the agent's pre-execution questions productively. How to practice: notice the questions you skip or wave through. The skipped questions are usually where the implementation goes wrong.

Recalibration witnessing. Learning how senior engineers diagnose stalls. How to practice: attend every recalibration session you can. Take notes on what triggered the diagnosis. The patterns accumulate into your own diagnostic skill.

Codebase intuition building. Understanding what this codebase wants. How to practice: before any non-trivial change, read 3 similar patterns in the codebase. Notice the conventions. Match them.

Asking better questions. The single skill that most accelerates engineering growth. How to practice: before asking any question, write down the question. Read it back. Is it clear? Is it answerable? Does it show what you've already tried? Re-write before asking.

Context contribution. Adding to shared prompts, scenario libraries, runbooks. How to practice: one small contribution per sprint. Even a single edge case added to the team's scenario library compounds.

Pick the skill that maps to your most recent stuck moment. Practice it for two weeks on real work.

How this differs from the legacy junior/mid Software Engineer role

Legacy junior engineer (pre-AI)	Software Engineer (AI-native)
Spends most of the day writing code by hand	Spends most of the day reading specs, reviewing agent output, and learning to specify
Learns by writing many lines of simple code over months	Learns by reading specs, watching reviews, and participating in recalibrations
First 12 months are mostly CRUD and bug fixes for trivial issues	First 12 months include meaningful feature contributions because the agent handles the trivial layer
Senior engineers are scarce time; pairing is rare	Pairing happens through specs, PR reviews, and recalibration sessions; senior judgment is more accessible
Career path: Junior → Mid → Senior, slow ramp	Career path: similar progression but with a faster ramp on meaningful contribution; T2.5/T3 reachable earlier
Best junior engineers are the most prolific	Best junior engineers are the clearest readers and writers

The role is not "a legacy junior dev with AI tools". It's a different apprenticeship, and the craft you're building is different.

Which role evolution patterns are in play

Elevation (primary, but from a different starting point). Like the Senior FSE, your work shifts from execution to specification and validation — but you're learning both crafts simultaneously rather than transitioning from one to the other.
Convergence (secondary). Like senior engineers, you operate across the stack earlier than legacy juniors did, because the agent handles whichever layer.
Emergence (partial). Some of the apprenticeship rituals — clarification dialogue practice, recalibration witnessing, agent reviewer feedback loops — are genuinely new ways of learning the craft.

Specialization and Absorption don't meaningfully apply to your role itself, though Absorption does apply to the legacy junior-developer work pattern (volume of trivial code writing) that no longer defines the apprenticeship.