Software engineering now: what's changing and what to master

The role isn't "write code faster with AI" anymore. It's designing the system that lets AI agents write, test, and ship code you're still accountable for.

I've been saving screenshots for a year — threads, repos, job postings, benchmarks, arguments. This is the engineering-craft signal pulled out of that pile. Claude Code setup itself is covered everywhere else. This is about the craft around it.

TL;DR

• Vibe coding proves an idea. Production still needs error handling, rate limiting, and real backends.
• "Agentic Engineering" (Karpathy's term) is now a named discipline: spec-first, fixed review posture, test harness, parallel-agent design.
• Spec-first tooling went mainstream — GitHub's Spec Kit hit 126k stars and works across 25+ agents.
• Verification, not code volume, is the differentiator. TDD-first skill libraries have crossed 244.7k stars.
• Harness and loop engineering — the system around the model — is where AI pilots actually die in production.
• Security review is moving into the agent loop, not staying a post-hoc gate.
• "The AI did it" is no longer an acceptable answer in code review. Ownership is the baseline.
• The hiring bar moved from "can talk about RAG/agents" to "can ship and debug something under real load."

What's changing

Author → orchestrator. Engineers are increasingly managing dozens of parallel agents rather than writing every line themselves.

Ad-hoc prompting → fixed review posture. Teams that randomly mix real-time approval with end-of-run PR review produce inconsistent code. The fix isn't picking the "right" one. It's picking one and sticking to it.

README → constitution file. CLAUDE.md-style rules files are becoming executable architecture contracts the agent reads on every run.

Security as a gate → security in the loop. Pattern-catching, diff review, and commit-time validation now run inside the coding session itself.

Tooling speed as an assumption → a measured cost line. One team quantified 1,140 engineer-hours a year lost to a slow linter before migrating. That's a budget item, not a preference.

"Can discuss agentic systems" → "has shipped one." Interviewers are filtering for production experience, not vocabulary.

Design vs build → design engineers who ship. The line between designing an interface and building it is dissolving.

New tendencies and direction

Spec-first / agentic engineering. Write the spec and architecture rules before the agent touches code. Four pillars: spec-first, fixed review posture, test-harness-first, parallel-agent design.

Verification over writing code. TDD-first skill sets — failing test, fix, next feature — and dedicated review/audit skills are replacing "just generate the feature."

Harness and loop engineering. Prompt engineering is the message. Context engineering is what the model sees. Harness engineering is the system that gathers, acts, and verifies. Most failed AI pilots never built the harness.

Loops as infrastructure. A loop — automations, worktrees, skills, connectors, sub-agents, plus memory of what's done and what's next — is the floor above harness engineering.

Trust ledgers and budgets for autonomy. Production-grade agent systems earn unattended-run permission only after logged pass-rate evidence, with hard spend caps enforced in code, not policy.

Cost-aware model selection. Pick models by scored task and budget, not reputation. In one audit, a cheap model matched a premium one on issue coverage at 3% of the cost.

Instruction architecture as a transferable skill. The public system prompts behind Claude, Cursor, and others share the same shape — clear roles, explicit "do not" lists, a stated working model. Worth reading directly.

Practices that matter now

Architecture and frontend insights

Architecture patterns scale with seniority. Junior needs about 4 — layered, client-server, monolith, CRUD. Middle needs 12 — CQRS, event-driven, API gateway, outbox. Senior needs 20 — saga, strangler fig, sharding, service discovery, and crucially, knowing when not to use a pattern.

Five API paradigms now coexist on a single stack. REST, GraphQL, and gRPC connect software to software. MCP connects software to a model. A2A connects agents to agents.

Generative UI is emerging as "frontend for agents," with three patterns: pre-built components the agent picks from, a declarative schema the app maps to components, or open-ended HTML rendered in a sandbox. A streaming alternative to JSON-based generative UI (OpenUI Lang) claims 67% fewer tokens and 3x faster rendering, with Zod-typed contracts and zero arbitrary code execution.

Anti-"AI slop" design tooling is a new category — rule sets that ban the generic purple-gradient, centered-hero look, plus agent-ready design systems like Facebook's Astryx.

And the unglamorous one: ESLint + Prettier → Biome cut linting from 55.6s to 0.89s per commit. 98% faster, directly reproducible, measurable.

Proof points matter. On my own site: Lighthouse Performance 96–99, Best Practices 100, SEO 100, CLS as low as 0.001–0.036. That's a screenshot anyone can verify in thirty seconds.

Competencies to build

Traits of engineers who win now

They ship systems that survive real load — error handling, rate limiting, real backends — not just working demos.

They orchestrate multiple agents in parallel instead of pairing with a single assistant all day.

They build the harness once — specs, tests, review gates — instead of re-prompting from scratch every session.

They take full, explicit ownership of AI-generated code in review.

They treat security and cost as engineering constraints they design for, not someone else's job.

Tools worth adopting

Selling your engineering + AI skills

Publish before/after metrics you already have. A Lighthouse audit is instant, verifiable proof of craft — and it costs you nothing to produce.

Turn a real project into a case study. A public relicensing decision — say, moving a repo to PolyForm with a personal-use carve-out — shows architecture and legal literacy in one artefact.

Share your actual Claude Code session: the todo list, the diff size, the PR. Process evidence reads stronger than a finished screenshot alone.