RevanRevan
  • Blog
  • Projects
  • About
  • Resume
M. Rezky Revansyah Suprihono

QA Automation Engineer & Software Developer

Building reliable test automation and useful digital products.

Explore

  • Home
  • About
  • Projects
  • Blog

Connect

  • GitHub
  • LinkedIn

© 2026 M. Rezky Revansyah Suprihono. All rights reserved.

Bekasi, Indonesia

    Back

    AI Writes the Code. Engineers Own the Consequences.

    Why coding agents are shifting our real bottleneck from writing syntax to architecture, testing, and system accountability.

    Published on September 29, 2026
    4 min read
    AI Writes the Code. Engineers Own the Consequences.

    Last week, an AI coding agent generated a 400-line microservice feature for me in less than forty seconds. It had TypeScript types, clean formatting, and passed its own mock tests on the first try.

    On paper, developer productivity was up by 500%.

    Two hours later, manual regression and edge-case testing exposed the problems: the service could not handle database connection pool exhaustion under concurrent load, silently dropped foreign key constraints on cascade deletes, and introduced architectural coupling that would have put our upcoming release at risk.

    The AI did not break production. If that code had shipped, I would have been responsible.

    That is the shift every software engineer needs to understand: AI can generate code at almost no marginal cost, but human engineers still own the consequences.

    The death of syntax and the rise of engineering

    For decades, the industry treated coding and engineering as if they were the same thing. Developers were often judged by how well they remembered syntax, solved whiteboard puzzles, and wrote boilerplate by hand.

    AI coding agents have separated those jobs:

    • Coding translates a defined requirement into a programming language.
    • Engineering means making decisions: balancing trade-offs, designing resilient systems, managing state, protecting users, and understanding how things fail.

    When code becomes quick to generate, the engineering work does not disappear. It moves to other parts of the process.

    Traditional workflow: Requirements → Write code (70%) → Test and review (30%)

    Agent-assisted workflow: System design (40%) → Agent generation (5%) → Verify, test, and QA (55%)

    Why 10,000 lines of unchecked code become technical debt

    “Vibe coding”—prompting an agent until an app appears to work—is exciting for weekend prototypes. In production, though, every line of code becomes something a team may need to read, debug, refactor, and secure.

    When teams flood a repository with code they have not checked, they are not simply moving faster. They are taking on technical debt without understanding its shape.

    The bigger risks are usually not syntax errors. They are gaps in how the system is understood and maintained:

    • Architectural erosion: An agent may solve the immediate prompt without understanding the wider domain model.
    • Missed edge cases: The happy path can work while race conditions and resource leaks remain hidden until load increases.
    • Reviewer fatigue: Reviewing 1,000 lines of generated code can demand more mental effort than writing 200 carefully designed lines.

    A better workflow: plan, delegate, test, review

    Pragmatic engineers are replacing blind generation with a disciplined loop.

    1. Plan and bound the context

    Do not ask an agent to “build a feature” without giving it clear boundaries. Define the data contracts, error budgets, and interfaces first. An agent can only work within the constraints and context it receives.

    2. Use the agent for implementation

    Treat an agent like a junior developer with plenty of stamina but limited understanding of your domain. Give it small, well-defined tasks instead of asking it to design an entire system at once.

    3. Verify the result, including edge cases

    If AI makes writing code cheap, verification needs to be deliberate. End-to-end and integration tests, along with performance checks, help catch mistakes that a successful mock test can miss.

    4. Review the architecture

    Ask whether the implementation follows the project’s design patterns, adds unnecessary dependencies, and will still be maintainable a year from now. Review the system the code creates, not just whether the feature works once.

    The real superpower of the modern engineer

    An engineer’s value is no longer measured by how many lines they can type in an hour. It shows in their ability to:

    • Recognize sound architecture and spot brittle shortcuts.
    • Ask, “What happens when this fails?” before a system reaches production.
    • Take responsibility for the systems they build and operate.

    AI has not made software engineering obsolete. It has taken some of the mechanical typing out of the work and put the focus back on what matters: critical thinking, system design, and accountability.

    0
    0
    0
    0
    0
    Last updated: September 29, 2026