Working with your new AI teammate
Written by Igor Shults
A note from the author: “I swear I didn’t use AI to write this blog post; I just really like my em dashes.”
The developer landscape has permanently changed in the last couple of years thanks to the advancement of AI coding tools. Although the future and full capability of these agents is uncertain, they have cemented their place in many developers’ toolboxes. As a result, understanding both their strengths and limitations—and the responsibility that still rests with the developer—is more important than ever.
In many ways, using an AI coding tool is a lot like working with another member of your team – you need to learn how to communicate with them, you need to use your own judgement when you think they may be wrong, and you must take all suggestions with a grain of salt. Based on my experience—primarily with Claude Code and Microsoft Copilot—I’ve found several approaches that make collaboration with my AI teammate more effective. While these examples are tool-specific at times, the underlying principles should be applicable to other AI coding agents. It’s also worth keeping in mind that the environment is constantly shifting and each tool has its own nuances, so these suggestions should be subject to your judgement and interpretation.
Asking better questions
Most AI model documentation recommends asking one question at a time. While this may feel less efficient upfront—and may marginally increase usage costs—it ultimately helps you get clearer, more accurate responses. Multi-part or meandering prompts can cause the agent to get sidetracked or confused, forcing you to re-ask questions, wasting time and tokens anyway.
The quality of the answer you receive depends heavily on the quality of the question. (see StackOverlow’s “How do I ask a good question?”). This is true of humans and LLMs. Being precise, clear, and specific is critical. If you were to tell a co-worker the code “doesn’t work” without explaining the error, expected behavior, or context, they will probably be annoyed and brush you off. Doing the same with the AI coding agent – giving it vague prompts – can lead the agent to confidently generate incorrect answers.
When your question is more complex, or has multiple parts, providing examples can significantly improve results. This “multi-shot” approach helps the agent retrieve information specific to your task. Referring the AI agent to specific code or other examples – i.e. Look at the data table in my Spock test Xyz and follow that pattern for the new test for Zyx – can guide it toward a more relevant and usable output.
If your requirements go beyond a single task, such as adhering to specific coding conventions or style guidelines, it may be worth using your tool’s personalization features. Options like Claude.md allow you to define preferences such as avoiding certain language features, reducing excessive commenting, or eliminating emojis. Different models handle these suggestions differently, and they’re not always applied perfectly, so you may need to prioritize only adding the most important ones. In Claude’s case, as of January 2026, the general sentiment is keeping this under 300 lines.
While there’s no harm in being polite, you don’t need to say “please” and “thank you” to your AI teammate. While there is some evidence that suggests that being polite may yield better results—likely because of patterns in the training data—modern models have likely been finetuned to present the best information, even if the user doesn’t mind their P’s and Q’s. If you are sending a message that only says “Thank you”, you are just wasting tokens and energy.
If you make a mistake in your question, or if the agent goes off on a tangent you didn’t expect, it’s generally better to re-edit your original question than to try to correct the LLM. Correcting it/calling it out may pollute your session with irrelevant information and consume valuable context window space. Rephrasing the prompt can also help you determine whether the task is even a good candidate for AI assistance in the first place.
When AI Assistance Works Best
As they currently stand, AI agents do make mistakes, and therefore code that they produce (even if reviewed by another AI agent like Copilot) needs to be verified by a human developer. Small, maintainable units of code that you can vouch for are a safe use-case for AI. You should treat AI-generated code as if you wrote it yourself—after all, it’s not the AI that gets paged if something breaks in production. Be careful not to blindly trust provided code, just as you would with any other teammate.
My colleagues and I have found that AI agents seem most effective when we generally know how to write the code we’re asking for. We know what to expect and where any major pitfalls are, making it easier to catch mistakes and verify correctness. Boilerplate tasks, such as setting up a new Spring Boot service or wiring an API client, are particularly well-suited for AI assistance and can save significant time.
Proofs of concept are another strong fit for AI agents. When factors like security, maintainability, and edge cases can be set aside, AI agents can help you quickly spin up something for a demo or meeting. However, POCs are notorious for becoming end-products, so just be sure to scour through the code to ensure there are no security gaps or missed business rules if it gets promoted to a viable product!
Having AI generate unit tests can save a lot of time and is generally worth the extra effort spent reviewing the files. Personally, I like to ensure that I can make the tests fail before committing them to the repo, since a tests may pass when it’s not verifying anything, or is set up incorrectly. Special care needs to be given to verifying AI-generated unit test for AI-generated code, as this combination may result in code that a human has never reviewed.
Riskier Scenarios
Extra scrutiny is required when working with languages or frameworks that are unfamiliar to you. I’ve learned a lot of Python with Claude’s help, but I could not stand by that code in the same way I could vouch for my Java code. This doesn’t mean you can’t use AI tools to get off the ground, just remember- you don’t know what you don’t know! The agent may make assumptions about configuration, security, or other use cases that you’re not equipped to challenge. In these situations, AI-generated code should be viewed as a learning aid or starting point, not a finished product.
The same caution applies when working in unfamiliar domains, such as system administration or shell scripting. Your AI tool wants to be helpful and will certainly tell you how to change all the permissions in your root folder so your Docker container can access them, but it may not tell you that that’s a bad idea. As a friend of mine put it, “AI is not so great at the XY problem.”
AI agents are also a poor choice for non-trivial mathematical problems. If you are asking it to calculate probabilities, the solution to complex math formulae, or (gasp) encryption keys, remember that AI agents are extensions of large language models and—as of January 2026—not calculators. This means they are drawing results from their existing knowledge (generally) and, unless your exact question is in its knowledge base, is will give an answer that may not be the right one. I’ve gotten bad results with regex as well. That’s an egg we may never crack.
Professional Etiquette
There are a few things to keep in mind when using AI-assisted tools at an organization. This includes not using them if the company, Github repo, or open-sourced project asks you not to. Please respect the rules of the community to ensure trust in both the code and in developer tools remains high!
Historically, developers would copy-and-paste entire functions from StackOverflow to solve unfamiliar problems, often adding a comment linking to the original source for context. I would urge developers who are adding AI-generated code wholecloth to a critical piece of the codebase to do the same. This will ensure extra care is given during code reviews, explain any differences in code style, and give a hint for future developers to take extra care with the function. This approach may not be necessary as AI tools improve, but like with any auto-generated code, a disclaimer (as simple as “This method AI-generated”) may help with future debugging. The time you save may be your own.
Finally, treat AI-generated code review comments the same way you would feedback from a helpful but imperfect coworker. Address the obvious and critical issues, but don’t feel obligated to act on every suggestion. This is especially important when contributing to external repositories—automated feedback should never override established project standards or best practices.
Hopefully these suggestions will help you as you get started on your journey with your AI teammate. The AI ecosystem is constantly evolving, and as the tools change, so may some of these guidelines. For now, though, thoughtful collaboration—with both human teammates and AI ones—will go a long way toward better outcomes.
Key Takeaways
- Treat AI coding agents like junior teammates: helpful, fast, and imperfect—always apply your own judgment.
- Ask clear, focused questions and provide concrete examples to get the best results.
- Re-edit prompts instead of correcting the AI mid-stream to save time and context.
- Use AI most confidently for small, verifiable units of code, boilerplate, POCs, and test generation—always review the output.
- Be cautious when working in unfamiliar languages, domains, or with advanced math, encryption, and regex.
- Follow organizational and community guidelines, and be transparent when introducing AI-generated code into critical paths.
- Remember: you own the code, the consequences, and the pager—AI is an assistant, not a replacement.
