The whole internet is full of articles that either glorify AI coding skills/agents or simply bash them as useless or malicious. I want to offer a simple engineering perspective on what it looks like, at the current stage, to use them on real-world problems.

We will discuss different use cases for these tools, either integrated or standalone. We will share insights on where they help and where you should not expect miracles.

Common tool types used by engineers

We can group commonly used AI tools into three categories:

Generative AI - tools used by engineers without the context of a codebase. Type in a question, upload supporting documents, and get an answer (ie ChatGPT)
Contextual AI- tools that integrate with your IDE and works like autocomplete on steroids (ie Github Copilot)
Agentic AI - tools that integrate deeply with your IDE and performs actions in the context of the full codebase (ie Cursor)

Use Cases

Let’s look into several common development use cases and look how those tools can help you:

Discovery efforts
Documentation to code
Verify feasibility
Data transformations
Plumbing code
Initial setup
Test data/cases
New language or technology

Discovery efforts

Sometimes, when working with legacy code, you just need to pull out/structure/transform data that already exists but is spread across multiple places or is in a format that is unusable by the app. Here AI tools really shine and can help you quickly come up with a console app/code snippet/script that will extract and transform your data. It’s easy to prompt and get an initial skeleton of a tool to perform the conversion.

Do expect to understand what you’re doing; in most cases it won’t work out of the box, but minor tweaks and input can resolve the issues. Usually it’s faster to modify the generated code rather than modifying the prompt to get the desired result.
Works best with generative AI tools (such as ChatGPT), as you don’t need much context and it’s easy to move code.
For these efforts, the prompt and code are usually discarded or archived after the analysis is complete.

Documentation to code

If you have high-quality documentation or input data, it makes sense to use AI to move from documentation to code. Independent prompts can generate user stories for developers from diagrams. Agents can generate base classes and structures for DDD approaches.

This assumes documentation exists and is of good quality, consistent, and well formatted.
It takes time to get prompts right. You must supply a lot of context to get the required output. It’s best to store those prompts with the code to make them reusable.
Expect some requirements not to be followed, especially if they are not mainstream.

Verify feasibility

Sometimes you need to verify whether a technical feature can be implemented in a certain way. It’s best not to use any existing context; simply ask the AI tool to create a snippet that demonstrates how the feature would be implemented and then apply that information to your own codebase.

Use generative AI (such as suggest mode or stand alone clients such as ChatGPT) to produce sample code to prove feasibility. The actual implementation still needs to be done in your codebase with appropriate verification.

Data transformations

Any data transformations—like text to JSON, XML to JSON, or removing some JSON fields—can be done with AI.

For smaller transformations, prompts can be enough.
```
given following JSON, rename attribute a to b and remove c, output JSON only:
<Your JSON>
```
For larger datasets, ask AI to create code sample for data processing to prevent hallucinations and make it reusable.

Plumbing code

Agents are pretty good at creating repetitive plumbing code, especially when transforming from specific samples or documentation. This saves mundane work and lets you allocate more time to architectural decisions.

Also works very well if you need specific algorithm implementation (like backtrack, etc.)
Verify the changes, as the agent doesn’t always follow instructions, even when explicitly stated.
Using keywords in prompts yields better results than writing in overly “nice” natural language.

Initial setup

Initial project setup can be handled by AI agents. If you are developing with a popular tech stack, agents can help you set up the initial structure so you can concentrate on features.

Do not expect agents to follow best practices; they are trained on internet data, which is inconsistent. Verify, or you will start with technical debt from day one.
If you have your own rules/templates/guidelines, it’s better to start with them to set context for the agent.
Different languages yield different results. Some produce outdated or even non-compiling code with outdated libraries.

Test data/cases

If you need to generate specific test data, AI is a good choice; it saves time and allows you to create more varied datasets without external tooling. AI is also good at inferring test cases for specific code.

One thing to know on the test-case side is that good code produces good test cases; bad code leads to redundant cases.
You still need to verify the AI output and discard unnecessary noise.

New language or technology

AI allows developers to onboard to new development language faster, as it can provide samples with appropriate libraries and some built-in patterns that you would otherwise need to look up.

Do not blindly follow the output it produces; use it as an accelerator, not a replacement.
Expect to get results with deprecated libraries or non-compiling code.

General observations

Performance is one of the most important factors. When you’re working, you don’t want answers to take long, or it becomes disruptive. Before committing to a specific tool, evaluate under real conditions. We’ve also observed that performance drops when the US wakes up; off-hours performance is better.

UI/UX matters. Some things to look for:

Easy toggling on/off — sometimes you don’t want any suggestions, and Tab should mean Tab, not a 2,000-line code change.
Checkpoints — you want a seamless undo after the AI fails your prompt.
Easy copy/paste — you want answers to be easily moved between apps.
Action confirmations — sometimes you want control before executing actions on large portions of your codebase.

Relevancy gives you more confidence and does not distract. Irrelevant passive suggestions only work until you disable them.

Explain before run is an important feature for cases where the AI tool is not most efficient. It allows you to verify its actions before running them, so you don’t need to undo multiple times.

Engineer growth is something to watch out for, as the tool removes the need for engineers to research/look up information, which means the breadth of competence and overall context might be reduced, potentially leading to worse decisions.

AI tool comparison

This comparison reflects my experience with the listed tools as of August 2025. Keep in mind, current capabilities may differ as each tool evolves.

	Cursor	Junie	AWS Q	Copilot	ChatGPT
UX, ease of use and seamless integration	Comes with its own IDE, this might be negative as usually teams already have IDEs that are used for products	Come from JetBrains so works best with JetBrain IDEs, might not be an issue if you already using their products	Integrates into your existing major IDEs as a plugin, this is a weak spot as plugin has bugs	Integrates into your existing major IDEs	Uses its own cloud based workspace, best fit as independent usage
Responsiveness	Very good performance or its perception as its fully integrated into custom IDE	We noticed some performance issues initially but it did observe improvements with updates, would still evaluate before committing to tool	Very slow to respond compared to other options, simple items are quicker to code manually rather that wait until it completes, would not recommend as goto tool.	Good performance, response is produced seamlessly	One of the most responsive options
Accuracy	Passive autocomplete is very good, even without prompting the completes are relevant and useful	Passive autocompletes are slow and rarely helpful	Passive autocompletes seems to be more distraction that useful feature	Most accurate suggestions, sometime its seems that it reads your mind	As non-agent flow produces very good results. Has plenty of “tools” that refine the answers. In some cases is too verbose and needs to be prompted to be concise
Autonomy	Is able to work on whole codebase and update relevant files. Allows you to accept actions to execute and allows partial updates from suggestions	Lacks simple checkpoint features, you need to commit before using or risk of code being rewritten	Lacks simple checkpoint features, you need to commit before using or risk of code being rewritten	You still need to verify all of the actions that it generates and approve them	No autonomy as you need to move content

Summary

My take on the AI frenzy:

AI will not replace developers in the near future. Current autonomy is very limited, and although it looks nice in prerecorded demos, it doesn’t look like that in real life.
Developers will not become way faster, but they can become more productive and improve codebase quality.
These tools have their place in workflows and are here to stay. They add to productivity if used correctly. Engineers will get used to them, and they will become a de facto standard in development.
To leverage AI effectively, you still need a consistent software delivery process, as structured input yields better results in any AI tool.

In general, I would bet that good engineers will use AI tools to improve their productivity and quality, but it will never remove the “garbage in, garbage out” rule from the equation.

Engineering with AI: help or hype?