The new normal of building software
A developer’s day used to revolve around typing every line: signatures, boilerplate, Stack Overflow tabs, paste from old projects. Today a modern engineer more often works with Cursor (an AI-first IDE) and Claude Code (a terminal agent): state the goal, set constraints, review the diff, and assemble a system from pieces the model generates in minutes.
Yes, that speeds up code generation. More importantly, focus moves from “type every line” to “design, verify, integrate”. The programmer becomes an architect and orchestrator.
What it looks like in practice
- Cursor: chat and Composer across the repo, edits applied in files, explanations of unfamiliar code, tests and refactors in project context.
- Claude Code: long agent sessions in the CLI — “enable SSR”, “fix CI”, “add a blog post” — with commands and iterations without copy-pasting prompts by hand.
- The human: defines goals and boundaries (security, style, architecture), accepts or rejects changes, owns production.
# Example task framing (intent, not dogma)
"Add /api/orders with validation, tests, and OpenAPI.
Stack: Spring Boot 3, Java 21. Do not touch auth. Follow existing package style."
The model writes code quickly. The engineer’s value is in what to ask for, how to verify it, and where it fits in the system.
Pros
- Faster codegen: CRUD, configs, K8s manifests, i18n, boilerplate — minutes instead of hours.
- Broader stack reach: easier to enter unfamiliar areas (Angular SSR, cert-manager, Quarkus Native) without weeks of ramp-up.
- Architect mode: more time on service boundaries, data, SLOs, risks — less on syntax.
- Learning in flow: a good model answer plus your review accelerates pattern and API literacy.
- Less context switching: search, edits, and explanations in one loop.
Cons
- Confident nonsense: code can look fine and still be architecturally wrong. Without review it becomes production debt.
- API hallucinations: nonexistent flags, outdated annotations, invented classes.
- Diff bloat: agents love to “improve everything” — you need a hard scope.
- Skill atrophy if you only Accept patches you do not understand. An orchestrator without fundamentals goes blind fast.
- Secrets and policy: do not feed keys, personal data, or restricted code without rules.
- Cost and lock-in: subscriptions, token limits, vendor dependence.
Rules that separate leverage from chaos
- One request — one goal (not “rewrite the whole project”).
- Always read the diff and run tests/builds.
- Own architectural decisions yourself: schemas, ADRs, module boundaries.
- Keep repo rules/skills so the AI writes in your style.
- Do not autopilot security and production incidents.
Personally: AI is my best tool
I will say it plainly: for me, AI is currently the best working tool. I used to be primarily a programmer — closing tasks by hand in code. Now I am increasingly an architect and orchestrator: I set goals, slice the work, steer Cursor and Claude Code, review the result, and assemble the whole.
The paradox I feel: codegen got faster, and my knowledge started growing much faster too. In a day I can walk through more real scenarios — SSR, K8s, native builds, SEO, Hibernate 6, refactors — and I still have to understand the “why”, not only the “how to type it”. AI does not replace thinking; it removes routine and leaves room for architecture, learning, and ownership of the system.
The upsides are huge. The downsides are real — which is exactly why the human role does not disappear; it levels up. People who can orchestrate models, read diffs, and hold the system picture win. People who blindly hit Accept accumulate hidden debt.
Takeaway
Cursor and Claude Code accelerate codegen and genuinely shift the job toward architecture and orchestration. For modern development this is no longer a toy — it is a working loop. For me personally it is the best growth tool: I used to write code as a programmer; now I more often design and manage how the system gets built, while deepening knowledge faster in parallel. The key is to remain the one who decides — not only the one who accepts a machine-written patch.