IntelliSense was one of Microsoft’s early innovations in coding assistance, first introduced in Visual Basic 5.0 (1996) and later expanded in Visual Studio 97. It helped autocomplete objects — for example, if you had an object called a steering wheel, it would suggest relevant properties and methods, saving developers from constantly looking up documentation.
The programming language, the object, and the IDE all worked together, so the programmer didn’t have to think as much about the syntax. It just completed as expected. This was way before autocomplete became mainstream with tools like Google Search. So, as programmers, we’ve been accustomed to this kind of augmentation for a long time. AI coding assistants are just an extension of that.
The Evolution of Coding Tools
Text editors like Vi and Emacs have been around for almost 50 years, shaping how developers write and edit code. Vi, for example, is like playing an instrument — if you get good at it, you can move code around incredibly fast. It allows you to repeat the last action 20 times, which is huge for making tedious tasks such as removing spaces from 100 lines more efficient.
Over time, editors evolved to make programming more efficient. Vi and Emacs had their hardcore, keyboard-driven approaches, and later, VS Code expanded on that with smarter autocomplete command-line integration and AI-powered assistance. A key shift was the introduction of the Language Server Protocol (LSP), which standardized how editors provide real-time feedback and suggestions across different programming languages.
The State of AI Coding Assistants Today
At TigerEye, we’re not limiting ourselves to a single AI coding solution because one of them is still impressive. There’s no clear winner.
We’ve looked at GitHub Copilot, Cursor, and Zed, and what’s clear is that the differences between them aren’t that significant. They’re all powered by similar models, and the real advantage comes down to the user experience within different editors rather than one AI being substantially better than the others.
To further our evaluations, the TigerEye team has also run local models to test them out. This requires a beefy machine, but it provides a private and free way to experiment with coding agents without sending code to external servers. This approach gives us more control over security, performance, and customization while letting us evaluate how well these models perform in real-world development workflows.
The big question now is: which one will evolve the fastest?
With traditional IntelliSense, autocomplete helped you fill in object properties. With AI, it’s possible to autocomplete much more, but it’s still not good enough to fully trust. You have to review everything. The AI can’t reliably write complete, production-ready code yet. The race right now is about which coding assistant will offer the cleanest, best-tuned user experience with the most valuable AI enhancements.
Where AI Coding Assistants Shine
AI is good at a few things:
- Writing Unit Tests: This is a significant pain for developers. Test-driven development requires you to write test cases before writing the actual code, which is a total slog. With AI, you can write the code first and let the assistant generate the test cases. It saves hours.
- Generating Boilerplate Code: AI can handle it well when you need to write a repetitive code block.
- Mathematical and Algorithmic Implementations: Say I need to interpolate colors between red and blue in 100 steps. AI can generate the math-heavy logic for that quickly and accurately. This kind of thing used to take 50+ lines of code and require manually working through formulas, but now I can just ask AI, and it spits out a high-quality implementation in seconds.
- Spotting Potential Bugs: I won’t replace formal security audits, but it can serve as a weak pair programmer or debugging assistant. A helpful prompt is, “I think this leaks memory. Show me where.” AI coding assistants can highlight potential issues and areas worth investigating.
We’ve seen AI assistants work well in real-world development. About 50% of DuckDB.dart unit tests were written by AI, and all API-specific code comments were either proofread or generated by AI for clarity and consistency. This has helped standardize documentation while saving time on repetitive test writing.
Where AI Coding Assistants Fail
- Systems Design: This is the core job of a mid-to-senior-level developer, and AI is terrible at it.
- Refactoring Code: AI doesn’t yet have the capability to analyze a complete codebase and meaningfully improve existing code.
- Understanding Context Beyond a Single File: While AI assistants primarily work on individual files, tools like Cursor’s Composer feature and Zed’s upcoming Suggest Edit feature are starting to address this by allowing programmers to specify which files are essential. However, this is still manual LLM context management, requiring engineers to guide the AI rather than the AI developing proper system-wide awareness. It’s improving, but far from seamless.
The biggest problem? AI lacks intuition.
Large language models can’t think in a way that allows them to design large-scale systems. They can summarize and regurgitate known best practices, but when it comes to real-world, creative system design… they fail.
It’s like asking an AI to design an entire startup from scratch. It can give you high-level advice (because there are books and blog posts about it), but it can’t do the work.
Security and Privacy
TigerEye does not use AI tools that apply to our entire codebase. We only use AI with zero data retention; nothing we type is stored or used for model training.
This is table stakes for us. We don’t send proprietary code to external models unless we explicitly control its handling. Many companies should pay more attention to this.
The Future of AI-Powered Development
The next big leap in AI coding assistants will be when they start learning from how developers work in real time.
Right now, AI doesn’t recognize coding patterns within a session. If I perform the same action 10 times in a row, none of the current tools ask, “Do you want me to do this for the next 100 lines?” But Vi and Emacs solved this problem decades ago with macros and automated keystroke reduction. AI coding assistants haven’t even caught up to that efficiency level yet.
Eventually, AI assistants might become plugin-based so developers can choose the best AI-powered features for their preferred editor. Deeply integrated IDE experiences will probably offer more functionality, but many developers won’t want to switch IDEs.
Will AI Replace Developers?
No.
The idea that AI will replace software engineers is nonsense, especially for junior and mid-level roles. What AI will do is make good engineers much faster. It doesn’t eliminate jobs; it augments individual productivity.
This is the fundamental shift: 10x engineers are no longer unicorns.
With AI, most mid-to-senior engineers can be 10x engineers now.
Final Thoughts
AI coding assistants have potential, but they’re not game-changing yet. Right now, they:
- Speed up repetitive coding tasks (tests, boilerplate, algorithms)
- Make learning faster (explain concepts like a CS professor)
- Fail at system design (no real-world problem-solving ability)
- Lack of full project context (only work on single files)
The best approach today is to use AI where it’s strong and ignore it where it’s weak.
Software engineering is a fast-paced career. Languages, frameworks, and technologies come and go, and the ability to learn and adapt separates those who thrive from those who fall behind.
AI coding assistants are another evolution in this cycle. They won’t replace engineers but will change how engineering is done. The key isn’t resisting these tools; it’s learning how to use them properly and staying curious about their capabilities and limitations.
Until these tools improve, the best engineers will be the ones who know when to trust AI, when to double-check its output, and how to integrate it into their workflow without becoming dependent on it.
The post AI Coding Assistants Are Reshaping Engineering — Not Replacing Engineers appeared first on The New Stack.
