Software development

AI saves me a lot of development time. I still don't trust it blindly.

I use AI to develop faster, but a proposal is not a verified result. How I approach planning, code, tests, user experience and production with it.

I use AI in development because it saves me a lot of time. I see no reason to dress that up or hide it. It helps me think, prepare code, hunt for bugs and write documentation. It's much easier to start from something concrete than from a blank screen every time.

But speed is not the same as correctness. That's a distinction I want to keep even when the tool explains very convincingly that the task is done. If the result isn't what I need, it doesn't help me much that it came quickly.

I look at AI as a collaborator with whom I can reach a proposal faster and then check it. The decision about what I actually want to build has to stay clear in my own head. If I can't explain it, it's unlikely that a better-worded prompt will magically stand in for it.

I can lose the most time before the first line of code

When I have an idea, I'm quickly tempted to start building. With AI that step is even easier: I describe a feature and soon I have screens, a data model or the first files in front of me.

That's why I'd like to stop early enough at the basic question. Which problem am I solving, and for whom? If I'm adding a field to an application, what will the user do with it? If I'm preparing a new page, which question does it have to answer? If I'm automating a process, which part of it even makes sense?

AI is useful to me here as a sparring partner. It can suggest options, point out a missing step or help break a bigger idea into parts. I take its proposal as something that makes it easier to think. Not as a decision I have to accept because it's nicely laid out.

With my own products, such as Bizko, what interests me most is whether the workflow is actually useful. If the goal is less re-entering of data, a new feature must not simply move the same work to a different screen. That is a question of design. The amount of generated code doesn't answer it.

Clear instructions are not just a longer prompt

For me, a good instruction says what I want to achieve, what already exists and what must not be broken. Length by itself isn't a particularly good criterion.

If I tell a tool to "improve the user experience", I've left it a lot of room for interpretation. It can change colours, add animations or rearrange the menu. All of that can be described as an improvement if I haven't first said what is currently causing the user trouble.

I find it more useful to describe the task and the expected behaviour. Take a hypothetical form: when the input is wrong, the user has to understand the error and keep the fields they've already filled in. That can be verified. The word "modern" is a lot more open-ended.

Constraints matter too. Are we working in an existing project? Which technologies does it already use? Does the change affect login, data or payments? Is this a local experiment or production? If that goes unsaid, I can get a perfectly sensible solution for the wrong environment.

I don't want to assemble an architecture by accident

AI can suggest many ways to solve the same task. That's helpful, as long as each new suggestion doesn't bring one more library, a different pattern or an additional layer nobody needs.

I'd first look at how the project already works. Where is the domain logic, how is data read and written, how are permissions handled, how are changes deployed? A new feature has to fit sensibly into that picture.

I don't want an architecture that is interesting mainly to explain. I want to understand what will have to be maintained and where things can break. A smaller system often needs fewer parts, not more. Sometimes the best answer is to use the existing pattern, even if it doesn't look like a new and especially elegant solution.

AI can help me compare options. The responsibility for choosing one that fits the project stays with me. A proposal that is good on its own is not necessarily a good addition to a specific system.

Code is faster to get than to understand the consequences of

Writing code is where the time saving is most obvious. A lot of repetitive work can appear quickly, and I find first versions easier to correct once I can see a concrete implementation.

But when I review, I'm not only interested in whether the code runs. I want to know what it accepts as input, where it checks permissions, how it handles errors, and whether it touches data the task shouldn't touch. I'd be especially careful wherever data, or access to it, changes.

I don't need to understand every detail of a library, but I do need to understand the decisions my solution rests on. If a piece of code isn't clear to me, an explanation is a good start. Then I look at the implementation and the documentation as well. An explanation from the same tool that wrote the code is not independent proof that everything is correct.

I also don't want to change half the project without need when fixing one bug. A smaller, more transparent change is easier for me to judge. The speed of producing changes is no reason to give up a limited scope of work.

When hunting bugs I want evidence, not just a plausible explanation

AI is useful for forming hypotheses. From a description of the problem it can suggest what to look at, which piece of data is missing or where the cause might be. That can shorten the search.

Still, I'd like to define the bug well enough first. When does it appear? Can I reproduce it? What did I expect, and what happened? Without that, you can start fixing things that are merely near the problem.

If the tool suggests changing a setting, I want to know why that setting would produce the behaviour I observed. If the error is gone after the change, I'd still check whether I removed the cause or only hid the symptom.

I wouldn't want so many things to change at once while chasing one problem that I can no longer say which one helped. A sequence of small hypotheses and checks suits me better. AI can take part in it, but it's no reason to skip the basic logic of diagnosis.

Tests have to check what actually worries me

Tests can be written quickly too. That's why I don't want to judge them by number alone. What interests me is what could break and whether the test would really notice.

If a test only repeats the same assumption as the implementation, the two can agree and both miss the problem. I'd rather describe the expected behaviour from the point of view of the user or the system. What has to happen with correct input? With wrong input? Without the right permissions?

When saving, I'd also check that I can read the data back correctly later. With login, the logout. With a form, the error, not only the successful submission. With publishing, the difference between a draft, a scheduled post and what is actually public.

These aren't things I have to check the same way every time. The scope should follow the change and the risk. A small design tweak doesn't need the same procedure as a change to the data model. In both cases, though, I want to know what was checked and what remains open.

Code review and UX are two different views

Code can be technically tidy and still make the user's life harder. So for me a code review doesn't replace using the screen.

I'd open the page on a phone, move through the menu and try to complete a basic task. Do I understand the button label? Do I notice that the data is being saved? Do I know why a field is required? For questions like these a nice screenshot isn't enough.

AI can suggest improvements, but I want to judge them against the purpose of the page. An extra card, notification or animation isn't useful just because it was easy to make. Sometimes the better decision is to remove something.

Even with this blog, I had to look at the actual rendering, tone down a colour that was too strong and check the mobile width. That's a concrete part of how the site came about, not proof that some tool knows my taste on its own. The proposal and the final decision were separate steps.

Documentation should describe the state, not the intention

With documentation, AI helps me organise scattered information into something I'll be able to use later. Even so, I'd like to check whether what's written describes the actual implementation.

"Support added" isn't enough if I don't know for which cases. "Tests passing" isn't enough if they weren't run in the environment we're talking about. "Deployed" isn't enough if the package is merely staged on the server while the public site still runs the previous version.

Differences like these matter to me later, too. When I come back to a project, I need a usable description of the state, the limitations and how to verify things. I don't need a confident summary from which I then have to guess what really happened.

Deploying to production is still its own step

A working local version tells me a lot, but not everything. The server can have different permissions, settings, limits or data. So I don't want to treat deployment as a final routine move that doesn't need a proper look.

Before a change I'd want to know what I'm deploying, whether I need a database change, and how I get back to the previous state. After deploying, I'd check the public paths and the tasks the change affected. The home page opening doesn't yet mean that login or image upload work too.

When setting up this site, a problem with access to the public images showed up precisely after the transfer. Checking the actual URL revealed it; the successful preparation of the files on its own did not. That case is a good reminder for me of why I don't want to judge the final result only from a report of completed steps.

AI helps me do more and do it faster in development. It's most useful to me when, alongside that speed, I keep an overview of the problem, the changes and the checking. I don't need blind trust to get a lot out of it. I need enough understanding to know when I can continue and when I have to look again.

Photo of the author

I build web solutions and digital products. At GE-KO I work on web design, development and SEO; with Bizko I look for simpler ways through everyday business. I am interested in how technology saves people work, and in how AI is changing the web.

One step further.