The Shift From Autocomplete to Agents: What Changed
Two years ago, the state-of-the-art AI coding tool was GitHub Copilot—basically autocomplete on steroids. You’d start typing a function, and it would suggest the rest. It was useful for the obvious cases—writing a for loop, implementing a standard algorithm—but it required you to direct every step. You had to know what you wanted to build.
That’s fundamentally different from what’s possible now. Modern AI coding agents can understand your codebase, understand your intent from a description, and write or modify code across multiple files to accomplish a goal. You describe what you want, the agent breaks down the task, writes the code, runs it, sees what breaks, and iterates.
This is not incremental improvement over autocomplete. This is a different mode of operation entirely.
The shift happened because of a few technical developments. First, LLMs got better at code understanding and generation. Models like Claude 3.5 Sonnet and GPT-4 are genuinely good at reasoning about code. Second, LLMs can now work with larger context windows—they can read entire codebases instead of just single files. Third, we figured out how to let LLMs execute code and iterate on feedback. You ask it to write a function, it writes it, you run it and show the output, and it iterates.
This last part is crucial. The first-order output from an LLM coding agent is often not perfect. But if the agent can see the error, it can fix it. This iterative loop is where the real value emerges.
Claude Code: The Agentic Baseline
Let me be direct about my bias here: I use Claude Code (Anthropic’s implementation, which I can access through the Claude website and through the Anthropic API). I’m biased toward it because it’s the best implementation I’ve used of agentic coding. But I’m going to try to be fair about what makes it work.
Claude Code is built on Claude 3.5 Sonnet, which is genuinely excellent at code. It can read your codebase, understand the architecture, and write code that fits into it. It can work across multiple files simultaneously. You can give it a task description and it will break it down into steps, implement each step, run tests, and iterate.
The specific thing Claude Code does well: understanding context and maintaining coherence across a large scope. If I say “refactor the authentication flow in this Django app to use OAuth2 instead of session-based auth,” it will actually understand what’s currently there, what the trade-offs are, and make changes that actually work. That’s much harder than generating code in isolation.
Concrete example from my own work: I had a Python bioinformatics pipeline that was processing genomics data, and the performance was bad on large files. I fed the entire codebase to Claude and described the bottleneck. It read through the code, identified that the problem was in-memory processing of large matrices, suggested vectorizing with NumPy, made the changes, and showed me the performance improvement. Would I have figured that out myself? Eventually. But it would have taken hours. Claude did it in minutes.
The limitation: Claude Code works best when you can give it clear context and clear goals. It’s less useful for truly exploratory work, where you’re not sure what the right solution is. And it’s not a replacement for actual testing—it will write code that looks reasonable but fails in production if you’re not careful about reviewing and validating it.
Cursor: The IDE-Native Approach
Cursor is a code editor built on VS Code that integrates AI into the editing experience. Instead of switching between your editor and a separate AI interface, the AI is native to the editor. You can highlight code, right-click, and ask the AI questions. You can start typing and get AI suggestions. You can select a block and ask the AI to refactor it.
The advantage is workflow integration. You’re in your editor, your hand is on the keyboard, and you can ask for help without context-switching. It’s faster for certain types of work—small refactors, bug fixes, extending existing code.
The disadvantage is the AI context is smaller. When I’m using Cursor, the AI is typically looking at the current file and maybe a few related files. When I’m using Claude Code, I can feed it the entire repository and the AI understands the full picture. For large refactors or architectural changes, that matters.
Cursor also handles iteration well—you can ask it to modify its previous suggestion, and it understands the conversation. But it’s less good at the “I don’t know what the right solution is, help me think through this” conversations that work well with Claude Code.
My use case for Cursor: small, contained work in a known codebase. New feature in a module I’ve written before. Bug fix in familiar code. Cursor is faster because I don’t need to move to a new tool.
GitHub Copilot: The Enterprise Play
GitHub Copilot is where autocomplete went when it got smarter. It’s integrated into many IDEs (VS Code, PyCharm, Vim, etc.), and it offers a freemium model with a paid version. Most developers have used it.
Copilot is good at autocomplete. Start typing a function, and it suggests the body. Start a test, and it suggests the rest. This is valuable for routine work—you save typing, you avoid typos, you keep momentum. For someone writing a lot of standard code, Copilot is a permanent productivity boost.
But Copilot isn’t agentic in the way Claude Code or Cursor are. It doesn’t understand your entire codebase. It doesn’t break down multi-step tasks. It doesn’t iterate on failures. It’s autocomplete for the LLM era.
Where Copilot has an advantage: it’s integrated into many IDEs and build systems. It works with VS Code in a native way. It has integrations with GitHub, pull requests, and CI/CD pipelines. For a team already using GitHub and VS Code, it’s the path of least resistance.
For biotech companies, Copilot is fine if you’re doing routine development work. For more complex tasks, I’d reach for Claude Code or Cursor.
OpenAI Codex / ChatGPT for Coding
GPT-4 and GPT-4o (OpenAI’s current model) are excellent at code. You can use them through ChatGPT or through the API.
The trade-off with OpenAI versus Anthropic: OpenAI’s model is faster for some tasks, especially multimodal work (if you’re doing computer vision). But Claude is typically better at reading large codebases and understanding architectural decisions. For pure code generation, they’re close to parity.
The practical difference for most people: ChatGPT is more accessible. It’s free (with limitations), it’s widely used, everyone knows how to use it. Claude Code requires an Anthropic account and some setup. For a solo founder, ChatGPT might be the easier starting point.
But if you’re building a company, I’d lean toward Claude Code or Cursor because they’re better at the deep context work that matters at scale.
Head-to-Head: Which Tool for Which Task
Large refactors and architectural changes: Claude Code wins. You need the full codebase context and the ability to make changes across files. This is where understanding the entire picture matters most.
Debugging and understanding what broke: Cursor or ChatGPT. You show it the error, it asks clarifying questions, it helps you think through the problem. This is more conversational and less about reading the whole codebase.
New feature development: Cursor if you know what you’re building. Claude Code if you need to explore options and understand trade-offs. ChatGPT if you just need a quick answer without context.
Scientific and research code (Python, R, bioinformatics): Claude Code, because research code is often poorly organized and the AI needs to understand the intent without great documentation. Claude is better at inferring intent from messy code.
Infrastructure and DevOps: Cursor or CLI-based ChatGPT. A lot of this is scripting and configuration, where context is less important and fast iteration is. Cursor’s IDE integration is nice here.
Code review and refactoring: All of them, but for different reasons. Cursor is fastest for small refactors. Claude Code is best for understanding if a refactor is architecturally sound. ChatGPT is good for generating alternatives.
The meta-lesson: these tools are complementary. You’re not choosing one. You’re choosing which tool to reach for based on the task.
AI Coding in Biotech: Real Use Cases
Let me ground this in the kinds of problems biotech companies actually have.
Bioinformatics pipelines: These are often Python or R scripts that take sequencing data as input and produce analysis results. They’re iterative—you run once, you get results that surprise you, you modify the script. AI coding agents are exceptional here because you can describe what you want the output to be, the agent writes a pipeline, you run it, you show the agent what’s wrong, and it iterates. I’ve seen AI coding cut pipeline development time from weeks to days.
Lab automation scripts: Controlling instruments, moving plates, triggering assays. These are often Python talking to hardware. Claude Code or Cursor can write this. The advantage: you don’t need to know the exact API of every instrument. You describe what you want (“move this sample from plate A to plate B, incubate for 30 minutes, read the absorbance”), and the AI writes code that calls the right APIs in the right sequence.
Clinical data analysis: ETL pipelines, data quality checks, statistical analysis. This is repetitive and often error-prone. AI can write the boilerplate, check the logic, suggest better approaches. This is a huge productivity gain for a small data team.
Drug discovery ML workflows: Training and evaluating models on chemical data, virtual screening, property prediction. Claude Code is actually good at this—it can write scikit-learn or PyTorch code, understand what you’re trying to predict, and iterate on model performance. I’ve seen AI coding accelerate ML iteration cycles significantly.
Documentation and scientific writing: Generate docstrings, write README files, create experiment reports. LLMs are good at this, and having it integrated into your editor is useful.
What AI Coding Agents Still Get Wrong
I want to be clear about the frontier of what doesn’t work.
Architecture and system design: AI can write code that fits into an architecture. It can’t (yet) design the architecture. You still need to make decisions about: how do you split this system into services? Where do you store state? How do you scale this? An AI can implement your decisions, but it can’t make those decisions for you. This is still a human job.
Performance optimization for latency-sensitive systems: AI can suggest optimizations. It often gets the low-hanging fruit. But it doesn’t have intuition about hardware, caching, memory hierarchies, and the kinds of micro-optimizations that make the difference between a system that responds in 100ms and one that responds in 10ms. For this, you need someone who understands the metal.
Security-critical code: AI can write code that’s syntactically correct and functionally reasonable. It often misses security implications. You should never rely on AI for authentication, authorization, encryption, or handling of sensitive data without extensive review. The model doesn’t understand the threat model the way a human security engineer does.
Writing tests that actually catch bugs: AI will write tests for your code. The tests will pass. But they often test the happy path and miss the edge cases where the code actually breaks. For security and correctness-critical code, you need human-written tests.
Understanding trade-offs: An AI can generate multiple approaches to a problem. But it often can’t articulate why one approach is better than another for your specific constraints. “This uses less memory but more CPU” is easy to state. “For our use case, we care about memory because we’re running on edge devices” requires understanding your business context.
Knowing what you don’t know: You ask an AI to write code, it writes code, and it’s plausibly wrong but you don’t realize it. The AI didn’t say “I’m not confident about this part” or “this might not handle this edge case.” In my experience, this happens when the AI is working in unfamiliar domains or with libraries it’s seen less training data on.
The pattern: AI is great at implementation and iteration. It’s less great at design decisions, security, and understanding constraints. Use it accordingly.
My Setup and Recommendations
If I were founding a biotech company in 2026, here’s what I’d do.
For the first engineer: Use Claude Code or Cursor, depending on preference. Set up a simple stack (Python for scripting, JavaScript/React for web UIs, PostgreSQL for data). Have the AI help build the initial infrastructure. It’s much faster than it used to be.
As the team grows: Use Cursor for daily development work—it’s integrated into the editor and keeps people fast. Use Claude Code for complex refactors and architectural decisions. Use ChatGPT for quick questions and debugging. Use Copilot if you’re already in VS Code and want a unified experience.
For research and pipeline work: Claude Code is the right tool. Feed it your messy research code, describe what you want to improve, iterate.
For code review: Don’t rely solely on AI. Human review catches things AI misses. But use Claude Code or ChatGPT to suggest refactors and ask “is there a better way to do this?”
For onboarding new team members: Have them use Claude Code or Cursor to learn the codebase. Ask the AI to explain how a system works. This is surprisingly effective.
The real productivity gain isn’t any single feature. It’s the ability to avoid context-switching, to get unstuck quickly, and to iterate rapidly on code. These tools give you that.
The Agentic Future: What’s Coming
A few predictions about where this is heading.
AI will become the default for routine code generation: By 2027, not using an AI coding assistant will be like not using an IDE with autocomplete—you can do it, but you’re handicapping yourself. This will commoditize routine coding work and increase emphasis on architecture, testing, and system thinking.
Specialized coding agents for biotech and science will emerge. A tool optimized for bioinformatics pipelines, or for ML model iteration, or for lab automation. Generic tools are fine for starting. Specialized tools will drive productivity.
Integration with testing and CI/CD systems will improve. Instead of writing code and then running tests, the AI will write code and run tests in real time, iterating until tests pass. This feedback loop will make agents faster and more reliable.
IDEs will become more agentic. Instead of just autocomplete, IDEs will have agents that can refactor, optimize, test, and deploy. Cursor is leading here, but VS Code, JetBrains, and others will follow.
AI-generated code will become a compliance and auditing issue. Especially in biotech and healthcare, there will be questions about: who’s responsible if AI-generated code fails? How do you audit it? How do you prove it was reviewed? These questions will drive regulatory clarity and tooling.
Conclusion: Agentic Coding is Here
The shift from autocomplete to agentic coding is real and it’s happening now. It’s not about AI replacing developers. It’s about developers being able to write more code, faster, with fewer bugs, and less tedium.
For biotech specifically, this matters because most teams are small and don’t have dedicated software engineers. An AI coding agent lets a scientist or a non-professional developer build infrastructure that would have required hiring an engineer two years ago. That’s a real competitive advantage.
The tool landscape is crowded and still evolving. My recommendation: pick one (Claude Code or Cursor are my top choices), get good at it, evaluate the others when you have specific needs that aren’t being met. Don’t overthink it.
If you want to stay ahead of where AI and longevity are actually going, subscribe to Accelerated — my weekly newsletter on the frontier of biotech and AI. Subscribe here