AI + Human hybrid Developers - The Worst of Us?

The current interface for software development still has shortcomings, and LLM-integrated IDEs get backlash in the engineering community for pushing developers out of jobs, and producing broken or poor quality code.

These IDEs introduce new features that attract developers at different stages in their career --- not just hobbyist and tech savvy business owners, but senior engineers at big name startups with high impact on products used by millions of users. Every time X has released a new Grok version, Cursor has a new feature, or Deepseek outperforms another model on various benchmarks, we're hearing arguments on both sides of how these tools should be applied in a safe and responsible way.

For enterprises, it's the risk taken on by making vital decisions and investments that depend on AI tools or advice.

There are a lot of solid applications in code documentation, summarization, git commit automation, integration automation, but code generation seems like it hasn't convinced the wider community of its value.

A well-placed criticism of LLM-assisted code is that many developers use generated snippets and chatbots without fully understanding the code before running it, leading to preventable breakage and security vulnerabilities in critical components. This is especially concerning when developers use the same AI system to generate both the code and its integration tests, or end to end tests, making debugging more challenging.

This makes sense. Entry-level developers, tech-savvy founders, and even senior engineers must evaluate whether AI tools assist them or hinder their ability to write "good code"—whatever that may mean to them and their business needs.

I used Perplexity to research how LLM-driven IDEs affect software developers. I've linked it here:

It found some interesting numbers:

• Tableau-to-PowerBI migration tasks are 80% faster using ETL pipelines and report templates

• Context aware recommendations can help enable project specific conventions, and not just generic patterns

• 40% reduction in task-switching penalties through automated CI/CD pipeline management

• SAPien's experiments showed 25% faster onboarding for junior developers using AI-generated code walkthroughs

• JetBrains' data shows developers using IntelliJ IDEA's AI assistant improve their adherence to SOLID principles by 18% quarterly

• Developers at IBM reported 60% faster sprint planning when using AI-generated user story mappings

• AWS CodeWhisperer reduces cloud infrastructure design time by 45% through cost-performance optimized templates

• Dify's error handling nodes demonstrate 92% success rate in automatic recovery from API timeout errors

• Autonomous agents can reduce CI runtime by dynamically prioritizing high-risk test cases based on code change impact analysis

However, it comes with some downsides:

• 35% of AI-assisted projects require dedicated refactoring sprints post-MVP

• The Eclipse Foundation now mandates AI checksum tagging for all automatically generated code blocks

The most impactful issues stem from:

• semantic drift (38% of critical bugs)

• hallucinated dependencies (27% of PyPI projects using AI code)

• security antipatterns (3.4 times more likely to cause top 10 OWASP violations)

• compositional errors (19% of system integration errors)

Technical debt to correct these issues is a serious concern, and developers in the beginning of their journey may find that evaluating the right areas to focus on is more challenging without a clear understanding of good software development practices.

More senior engineers may find that the code generated is only able to automate the most basic tasks in their workflow, preferring instead to have it help document and explain the code they write, or restrict it to generating boilerplate code.

Here's where it hits the hardest, too, when it comes to fixing AI code:

• AI code shows 60% fewer syntax errors, but 45% more logical flaws

• time to root-cause analysis is 30% longer due to non-linear patterns in code generation

• 22% drop in deep language framework expertise on teams that become over-reliant (over 18 months)

So developers have harder problems to fix, they're weirder problems, and they know less about it the more they depend on AI generated code over time.

What can developers do to use it safely?

• Increase manual intervention in the development process

• Reject low confidence code results automatically

• Track the progression of the logic over time with more insight into decisions made

• Learn best practices for prompt engineering

• Pair programming with human developers during the development process

• Check ACMs revised Code of Conduct for responsible tool usage

What can companies do to bring it into the SDLC?

• Phased rollouts that match competency levels on a team

• Invest in continuous learning and training on the tools

• Monitor technical debt closely with any AI generated code

What now though?

Well, this is referencing an AI written research paper, shouldn't it also be validated?

What do you think?