Coding in Tandem: AI as a Coding Partner

Introduction

When generative AI first emerged, I approached it with scepticism. As a backend developer with years of experience, I valued the craft of writing code and was reluctant to delegate any part of it to an algorithm.

Fast forward to today, and my workflow has transformed dramatically. I now instinctively launch Perplexity or Claude alongside my IDE as a part of my development setup, or I simply use Copilot plugins or IDEs that are already integrated with them.

It’s 2026, and AI has fundamentally changed software development practices across the industry. What began as experimental tools has evolved into essential components of the modern developer’s toolkit. In this post, I’ll share insights from my journey working alongside AI and how it’s reshaping both my personal projects and professional development.

Overview

• The Rise of AI Co-pilots - My first experience with GitHub Copilot and other AI coding assistants
  • AI in the Workplace - How different organisational contexts shape AI adoption
    • Corporate Banking - The unique limitations I faced using AI in highly regulated environments
    • Small-Scale Projects - Where AI truly shines and transforms development workflows
    • Bridging the Gap - How organisations of different sizes can leverage AI effectively
  • From Search Engines to AI - How AI is changing how we find and apply development knowledge
• Navigating the AI-Assisted Development Landscape - My personal guidelines for maintaining quality and ownership
  • Ownership and Responsibility - Taking full accountability for AI-generated code
  • The Art of AI Whispering - Crafting effective prompts for better results
  • Review, Review and Review Again - The importance of thorough code inspection
  • Leveraging AI for Learning - Using AI to expand your knowledge and skills
  • Resisting the Siren Song of Auto-Accept - Avoiding the pitfalls of blind acceptance
  • Keeping my Coding Muscles Strong - Maintaining core skills in the AI era
• Conclusion: Finding Balance in the AI Era - Final thoughts on the human-AI partnership

The Rise of AI Co-pilots

GitHub Copilot - Cursor IDE - Amazon Q

I ventured into the realm of AI coding tools with low expectations. I started by tossing questions at ChatGPT whenever I hit a wall in my Java backend work. While it sometimes came through with helpful solutions, I quickly bumped into its limitations. The narrow context windows and knowledge cutoff (which was back in September 2021 when I first started using it) meant it often drew a blank when I asked about newer technologies and solutions. Whether I was curious about recent Java features, the latest Spring updates, or trending cloud-native patterns, I’d frequently get that familiar “I’m sorry, but my training data only goes up to…” response. It was like having a coding buddy who’d been living under a rock since 2021—enthusiastic but perpetually behind on what’s happening in the dev world. 

The real eye-opener came when I installed GitHub Copilot. That first moment when it auto-completed an entire method body based solely on my descriptive method name felt like magic—I remember watching in amazement as it generated a complete implementation that handled all the edge cases I would have coded manually. The suggestions were sometimes uncannily accurate, as if it was reading my mind rather than my code.

But Copilot had its challenges, too. Its context awareness rarely extended beyond the file I was currently editing. When working on complex Java micro-services with multiple interconnected components, it would suggest implementations that contradicted patterns established elsewhere in the project. 

Since then, I’ve explored various AI coding assistants, including Amazon Q, which truly excels when working with AWS SDK and related tools. However, the standout discovery in my journey has been Cursor—an IDE built from the ground up around AI integration. What sets Cursor apart is its flexibility to choose between different LLM models (or let it automatically select the optimal one), its impressively large context window that understands more of your codebase, and a rich array of AI-powered features that have transformed my development workflow. It’s become my go-to coding environment for bit work and personal projects.

AI in the Workplace

The application of AI tools in software development varies significantly based on organizational size and complexity. In smaller projects with standard architectures, AI assistants provide immediate value through code generation and pattern recognition. However, larger enterprise environments present unique challenges that often confuse general-purpose AI tools.

Corporate Banking: Navigating AI Limitations

Having worked in the corporate banking industry, I've experienced firsthand the limitations of leveraging AI assistants like Amazon Q or GitHub Copilot. Several factors contribute to these constraints:

1. Code Security: Corporate codebases are highly secured, and integrating external AI assistants into IDEs would constitute a serious security violation, even with data sharing and self-learning features disabled.
2. Vast Domain Context: In large corporate environments, especially those using microservice architectures, the context is often too expansive for AI to work effectively. An error in one API might be caused by a different microservice with an entirely separate codebase.
3. Proprietary Practices and Libraries: Big corporations frequently use custom-built libraries that are hidden from AI as dependencies without public documentation. They also enforce strict coding practices, from naming conventions to tabulation and testing standards.

In this context, the only way to leverage AI's power is when encountering logical roadblocks. This requires simplifying the issue to a level where only the logical solution matters, often translating complex systems (like loan management) into simplified analogies (like a grocery store inventory and checkout logic) while obscuring sensitive details.

Small-Scale projects: AI’s Playground

For smaller projects or companies with less sensitive code and reliance on public libraries, AI can truly flourish:

• Smaller codebases often fit entirely within the context window of modern co-pilots, allowing for more comprehensive assistance.
• Public libraries and common architectural patterns are well-understood by AI, leading to more accurate suggestions.

However, caution is still necessary. I always recommend disabling the “Share conversations with AI provider” option (or its equivalent) to prevent accidental leakage of sensitive information like environment variables.

Bridging the Gap

This disparity highlights a growing advantage for larger organizations that can invest in customizing AI tools for their specific environments. They have the resources to train AI models on their proprietary codebases and practices, potentially overcoming many of the limitations I’ve experienced.

Smaller teams, meanwhile, adapt general solutions to their specific needs. While this may seem disadvantageous, it often leads to more agile and innovative use of AI tools, as developers find creative ways to leverage AI assistance within their constraints.

In conclusion, while AI's potential in software development is immense, its application must be tailored to the specific context of each organisation. Whether in a highly secure corporate environment or a nimble startup, the key lies in understanding the strengths and limitations of AI tools and adapting their use accordingly.

From Search Engines to AI

I used to Google everything, but now I just ask my AI assistant. My search history has gone from “Java concurrent hashmap thread safety” to “good excuses for missing a standup meeting”. (a bit of developer humour there—we all know standups are sacred).

The shift is subtle but profound. Instead of scanning through multiple search results, I get a conversational answer that feels more natural. Of course, I've encountered my fair share of entertaining AI blunders—like when my assistant confidently declared that the cutting-edge UI framework I was implementing in my side project was, in fact, a specialised Linux distribution for embedded systems.

Perhaps even more significantly, AI has largely replaced my daily pilgrimages to Stack Overflow. Those marathon sessions of opening twenty browser tabs, sifting through opinionated answers (some from 2012 and before), and navigating comments like “Why would anyone do it this way?” have become increasingly rare. The sacred ritual of copying error messages, pasting them into Stack Overflow’s search bar, and praying someone encountered the same obscure issue five years ago has been supplanted by simply asking my AI buddy to diagnose the problem.

The AI doesn’t just provide answers—it offers context, explains the underlying concepts, and doesn’t include the obligatory Stack Overflow comment questioning my entire approach to software development. That said, I do occasionally miss the shared experience of seeing other developers struggling with the same issues, and the validation that comes from upvotes confirming I’m not the only one confused by a particular API. There’s something uniquely reassuring about human confusion that AI hasn’t quite replicated yet.

One game-changer has been AI’s new context grounding features. Now, when I get answers, I also see where they came from—actual documentation, articles, or repositories. This means I can verify sources and dig deeper when needed. No more mystery meat solutions! It’s reduced those “wait, that’s completely wrong” moments and built my trust in AI suggestions. It’s like having a lead dev who not only solves your problem but also drops links to the docs so you can learn why it works.

Navigating the AI-assisted Development Landscape

I’ve watched AI tools steadily weave themselves into my daily coding routine, and along the way, I’ve realised how important it is to set some ground rules. Through plenty of trial and error (and a few memorable mistakes), I’ve developed personal guidelines that help me get the most from these tools while avoiding their pitfalls. These practices have become my compass for maintaining high-quality code and continuing my growth as a developer, even as I increasingly collaborate with my silicon-based friends.

Ownership and Responsibility

First and foremost, I always remind myself and everyone: Code written by an AI assistant is still your code. I treat AI-generated code with the same precision and attention to detail as if I had written every line myself. This mindset ensures that I maintain full responsibility for the outcome, regardless of its origin. It’s not as if I could march into my manager's office after a production incident and declare, "Don't blame me-the AI wrote that part!"

The Art of AI Whispering

I used to think I could just throw error messages at ChatGPT and get magical solutions. Spoiler alert: that approach leads to more confusion than code. These days, I treat writing prompts like I’m drafting a spec document. I provide context, explain what I’m trying to achieve, and outline any constraints. It’s like pair programming with a brilliant but easily confused partner - the more context you provide, the better the results.

Review, Review and Review Again

I’ll admit, there was a time when I’d skim AI-generated code and think, “Looks good to me!” and ship it. That approach led to some interesting debugging sessions and a few “How did this ever work?” moments. Now, I review AI suggestions with the same intensity as code written by a junior developer with a caffeine addiction. Every line gets scrutinised, and I’ve caught some subtle bugs that could have caused major headaches down the line.

Leveraging AI for Learning

When AI suggests an approach I’m unfamiliar with, I see it as a learning opportunity rather than a roadblock. I often ask the AI to explain its reasoning step-by-step, supplementing this with my own research. This practice not only expands my knowledge but also helps me critically evaluate the machine’s suggestions.

Resisting the Siren Song of Auto-Accept

The “Accept Suggestion” button in Copilot is dangerously tempting. It whispers promises of effortless coding and unmatched productivity. But I’ve learned to resist its siren song. Blindly accepting AI suggestions is a fast track to code you don’t understand and can’t maintain. Instead, I take a breath, review the suggestion, and only then decide if it’s the right fit for my project.

Keeping my Coding Muscles Strong

To make sure I don’t become overly reliant on AI, I regularly schedule “AI-free” coding sessions. It’s like going to the gym for my development skills - sometimes uncomfortable, often challenging, but ultimately necessary to stay in top coding shape. After all, you can’t exactly ask the interviewer for a quick break to consult your AI buddy when they hit you with a tricky algorithm question. “Hang on, let me just check with ChatGPT real quick”, probably won’t impress anyone in the hiring seat. 

By adhering to these practices, I’ve found a balance that allows me to harness the power of AI assistance while continuing to grow as a developer and maintain high standards of code quality. The key lies in viewing AI as a powerful tool to augment our capabilities, rather than a replacement for our expertise and judgment.

Final thoughts

The most effective approach to AI in software development is viewing it as an amplifier for human capabilities rather than a replacement. The optimal workflow leverages AI for routine tasks, pattern implementation, and knowledge retrieval while reserving human focus for architecture, business logic, and critical decision-making.

As we continue to refine this partnership, the developers who will thrive are those who understand both the capabilities and limitations of AI assistants. By maintaining this balance, we can enhance productivity without sacrificing the depth of understanding that characterises truly exceptional software development.

The future of coding isn't human versus AI, but humans and AI working in tandem—each contributing their unique strengths to create better software more efficiently than either could alone.