ChatGPT Delivered on the Coding Question

And Then It Behaved Like a Senior Developer

Where this started

Have you ever thought you had the perfect solution only to realize it was a bad idea? There’s a reason why slowing down enough to think it through first pays dividends.

Recently I asked ChatGPT to create a code snippet for How Work Happens Here. It was one of those coding assignments I could have given myself, but I knew that ChatGPT or Claude could do it faster. Once they were finished, I would test it, integrate it into the rest of the app, and check it off the list.

What we noticed

ChatGPT delivered instantly. I tested the code, confirmed it did the job, and I was ready to check it off the to do list. Then ChatGPT did what an experienced human tech team member would do. It commented that while my approach was lightweight and usable, I might consider one change that would make it more architecturally sustainable.

The more we talked through the approach, the more I realized that capturing the querystring was short-term thinking.

The conversation continued. We were uncovering the invisible work behind creating something people could trust.

I'm a huge fan of utility tools that clients never see. Building them at startup makes sense because we're thinking about all the manual steps we’ve done during our implementation. We anticipate where customers are likely to need help. We know where we can simplify the boring steps that make the experience effective, responsive, and repeatable. And that’s how one simple quick solution turned into a complete admin backend.

What we almost did

It would have been easy to stop after finding the best way to preserve the querystring value in the URL. Technically, that would have solved the original problem.

We also could have gone in the opposite direction and started building logins, user accounts, permissions, dashboards, and all the infrastructure that often appears around new software.

Neither approach felt right.

To be honest, I knew that building the backend for How Work Happens Here was the right thing to do. 35 years of lessons learned and habits are hard to ignore. Building the support tools that the clients never see sounds wasteful, but, in fact, they quickly pay for themselves.

But I wanted to skip that step for the moment anyway. I found a shortcut to get the immediate job done. And then along came a more responsible solution that I couldn’t unsee. I’m glad that ChatGPT encouraged me to slow down enough to reconsider my decision. What started as a quick coding request became the right kind of boring.

What we decided to do

Instead, we built just enough. We designed a nimble system around the tools, technologies, and infrastructure already in place.

We created secure client tokens, server-side validation, an administrative tool for creating and managing links, and a backend designed to support the experience without getting in the way. Every function addressed a real operational need rather than an imagined future requirement.

The goal wasn't to build a fancy platform. The single purpose was to make sure a client could receive a link, click it, and use the app easily. They didn’t have to think about what happened behind the scenes.

What we decided not to do

We’ve all fallen into the trap of “one more thing” thinking. You know, those it won’t take but a few minutes to add something while we’re in the coding flow anyway. Experience has taught us that nothing is quick, easy becomes complicated, and time is spent on building features that no one will ever use.

We didn’t introduce any new technology or change what’s already working. Our framework has been in production for more than 2 decades. It would be easy to introduce a few incremental updates, but that comes with unnecessary risks for no benefit.

So we were just as focused on what not to implement.

We didn't build full user accounts. We only captured the information we need.

We didn’t implement a login and user authentication system. What we built was solid and got the job done.

We didn't build a token management platform.

We didn't automate every administrative task simply because we could.

Some situations are so infrequent that opening SQL Server and running a simple update remains the most practical solution.

Experience has taught us that every feature carries a maintenance cost long after the excitement of building it is gone.

What we learned

One of my favorite takeaways from this project: there is the right kind of boring. It’s better to invest in the right kind of boring in the beginning. That means not only building it but constantly paying attention to it.

It’s like the gardener who tends to the rose bushes day after day. They’re doing the work that no one sees. The feed the roots. They make sure there is just the right amount of water. They pull the weeds. They inspect the leaves for pests. They aren’t focused on growing one flower at a time. They’re building the right reliable foundation below the ground to produce healthy flowers season after season.

Our customers appreciate the flower. We build the unseen foundation.

We could easily have skipped the unflashy backend that we built.

Step: Each new customer could be added to the database manually.

Step: Then we could manually execute the code that generates their unique link.

Step: We could write the welcome email every time and search through the database to find the company’s token.

Step: Then we could copy and paste their link into the email.

Step: When the customer forgets their link because that’s what humans do, we could generate another one and send a new email.

Step: Customers have questions. No problem. We could reply to them as soon as we search through past support emails, looking for the same question and answer.

Once you see the future, it’s nearly impossible to ignore it.

 

The original question wasn't wrong. It simply belonged inside a much larger system than I could see at first. That's often how sound decisions happen. One simple question and a thoughtfully considered answer lead to unexpected outcomes.

What surprised us

The biggest surprise wasn't the backend system we built. It looked very much like ones we have developed many times in the past. The surprise was the insight and perspective that ChatGPT provided. We didn’t see that coming.

I was operating with a preconceived idea of how we would support client access to a small app. It wasn’t wrong. It was just limited. Once a different question was asked and another option was explained, my thinking changed.  There is a tremendous value in listening to different perspectives.