AI coding tools are quietly changing a developer’s job into an architect’s job, and a slow Google Forms add-on shows why it matters. A developer investigating a performance problem found that the add-on’s welcome screen took 15 seconds to load, and the culprit was a few lines of AI-written logging code. The lesson, in this developer’s telling, is that AI coding architects have to make the decisions the tools won’t.
The 15-second welcome screen
A colleague had vibe coded the logging so he could track new installs every week. Watching new customers is a sound instinct for any business. The trouble was what the code tried to log: the user’s email address. Google has sharply limited the user details an add-on can read since last December.
The AI handled that with a chain of try/catch statements. First it tried to fetch the email, if the user had agreed to share it at installation. If that failed, it tried the user ID. If that failed too, it logged that someone had installed but that neither email nor ID was known.
Each step is one line of code. Each also makes several API calls to Google’s servers behind the scenes. Because logging ran first after installation, everything waited behind them, and a static welcome screen took 15 seconds.

What an experienced architect would have done
Someone who knows how many calls hide behind each method has two reasonable options. One is to log only the install timestamp and tell the marketing team they can’t send a follow-up email based on installation alone. The other, if marketing insists on the email, is to show the welcome screen first and log the email or user ID asynchronously from the browser while the user reads it. That route has a cost too: calling your own server from the add-on screen may mean accepting an unauthenticated payload.
The job, in other words, includes pushing back on requirements that slow the app down, or finding a workaround such as going async or accepting a reasonable hack.
Why AI won’t push back
The assistant had no way to know whether the product was just launching or had millions of users, and that fact decides whether a timestamp or an email is the right thing to log. It also tends to be agreeable and carries out requirements exactly as given. Told to log the email, it did, at the cost of a slow screen.
The same developer says that when you describe requirements and leave out the architecture, the AI chooses the architecture for you. Its default leanings are toward security and backward compatibility, which in practice means two recurring problems:
- Designs that give up performance for security, and so run slower.
- Several versions of the data model, with redundant tables, columns and code.
The developer says that even a hand-written unauthenticated payload may get rewritten as an authenticated one, which can hurt performance or force users to sign in again.
What the new job looks like
The advice is to design the architecture and data model first and ask the AI to code within those limits. Any new requirement that changes the design should make the tool ask before it changes anything. You also have to say when backward compatibility is needed, and when old logic and tables should be deleted so only one version remains.
For people already used to designing a data model, handing implementation to others and reviewing the result, this will feel familiar. Many developers weren’t hired for that. They loved writing code, and now AI writes most of it. Nobody told them the new duties: pushing back on requirements, designing the data model, constraining the AI and reviewing its output.
That gap, the developer argues, explains much of the confusion and resentment around vibe coding.
The fix for this add-on
The repair here was small: log the timestamp, show the welcome screen first, and tell marketing what they can’t get at install. The AI wouldn’t have made that call because it doesn’t know the users and won’t challenge a requirement.
The conclusion is that the coding work is going away, but the developer’s job isn’t. People without an understanding of architecture and design risk slow apps and unmaintainable database tables. For developers, the practical next step is to practice the review habits of an architect.
Source: Developer forever