Do you remember the first time you opened Excel and discovered pivot tables? Or perhaps that moment when you first held a digital camera after years of developing 35mm film? Maybe it was when you wrote your first SQL query and watched data magically arrange itself exactly as you needed it.

These technological transitions in our lives often follow a strikingly similar emotional pattern. The initial rush of discovering something that seems almost magical. The frustration when things don’t work quite as smoothly as we imagined. The determination to make it work through increasingly complex workarounds. The eventual understanding of where this tool truly fits in our workflow. And finally, the comfortable mastery where the tool becomes a natural extension of our capabilities.

As I’ve watched myself and others grapple with AI tools, I’ve noticed we’re experiencing these same familiar stages. Just as the Kübler-Ross model describes how we process significant changes in our lives, our journey with transformative technologies follows a predictable pattern of emotional stages. Whether it’s transitioning from manual photo editing to Lightroom, from basic spreadsheets to complex data analysis, or from traditional coding to AI-assisted development, the psychological journey remains remarkably consistent.

This isn’t just about AI – it’s about how we as humans adapt to tools that fundamentally change the way we work. By understanding these stages, we can better navigate our relationship with AI tools, just as we did with the technologies that came before them, and will do with tools and technologies that come in the future.

Stage 1: Euphoria – “This changes everything!”

The first interactions with AI tools often trigger an almost euphoric response. During this stage, developers may:

• marvel at the tool’s ability to generate code and solve problems
• share enthusiastically with colleagues and on social media
• make bold predictions about AI replacing traditional development
• overestimate the tool’s capabilities and underestimate its limitations

Possible examples

A frontend developer asks an AI to create a complex authentication system with social login integration. When the AI generates a complete solution in seconds, they immediately share screenshots on Twitter, declaring: “Traditional coding is dead! #AIRevolution.” They spend the next week feeding the AI increasingly complex problems, from database schema design to entire microservices architectures, convinced they’ll never need to write code from scratch again.

Another developer successfully uses AI to debug a tricky React performance issue and immediately starts planning to replace their entire code review process with AI analysis, certain that human code reviews will soon be obsolete.

Tips for navigating Stage 1

• Channel your excitement into structured experimentation
• Document your AI interactions and their outcomes
• Set aside dedicated time for AI exploration to avoid disrupting regular work
• Share your discoveries, but maintain professional scepticism
• Start with small, verifiable tasks before moving to complex problems

Stage 2: Disillusionment – “This isn’t what I expected”

Reality, and possibly discouragement begins to set in as the tool’s limitations become apparent:

• Generated code often requires significant debugging
• Solutions are sometimes outdated or follow deprecated patterns
• AI occasionally produces confident-sounding but incorrect answers
• Time spent prompting and verifying sometimes exceeds traditional coding time

Possible examples

The same frontend developer who celebrated their AI-generated authentication system discovers security vulnerabilities in the code and realises the AI used deprecated OAuth flows. They spend three days fixing issues that would have taken one day to code manually.

A team lead implements AI-powered code generation for their sprint, only to find that 60% of the generated code fails their test suite and requires extensive refactoring to match their codebase’s patterns and standards.

Tips for navigating Stage 2

• Focus on learning from failures rather than dwelling on disappointment
• Document specific limitations you encounter for future reference
• Join communities where developers discuss AI tool challenges
• Start developing verification strategies for AI-generated code
• Remember – all tools have limitations!

Stage 3: Bargaining – “Maybe if I just…”

In this stage, a developer might try to reconcile their initial expectations with reality:

• Experiment with increasingly complex prompting techniques
• Seek out ‘expert tips’ and ‘hidden features’
• Try multiple different AI tools hoping to find the ‘perfect’ one
• Attempt to combine AI tools with traditional development in various ways

There’s a persistent belief that with just the right approach or combination of tools, they can recapture that initial magical experience.

Possible examples

A backend developer creates elaborate multi-step prompts, spending hours crafting the ‘perfect’ system message that includes their entire tech stack, coding standards, and architectural preferences. They maintain a 500-line prompt template document, convinced that with enough context, the AI will produce perfect code.

A tech lead bounces between different AI coding assistants – trying GitHub Copilot for a week, then Claude, then GPT-4 – certain that one of them must be able to consistently generate production-ready code. They create complex workflows combining multiple AI tools, like using one for code generation and another for code review, hoping the combination will overcome individual limitations.

Tips for navigating Stage 3

• Create a systematic approach to testing different prompting strategies
• Build a personal library of successful prompts and patterns
• Set realistic goals for AI assistance in your workflow
• Focus on specific use cases where AI has proven most reliable
• Share and learn from colleagues’ experiences

Stage 4: Reflection – “I see what this really is”

A more nuanced understanding begins to emerge:

• Recognition that AI tools are assistants, not replacements
• Appreciation for the tool’s actual strengths and limitations
• Understanding of appropriate use cases
• Development of personal best practices for AI integration

This stage marks the beginning of a more mature relationship with AI tools, starting to see them as part of a larger toolkit rather than a complete solution.

Possible examples

A mobile developer discovers that while AI isn’t great at generating complete app features, it excels at helping debug crash reports and suggesting optimisation techniques. They create a workflow where AI assists in analysing crash logs and suggesting potential fixes, while they maintain control over implementation decisions.

A QA engineer realises that instead of trying to get AI to write complete test suites, it’s more effective to use it for generating edge cases and test scenarios. They develop a hybrid approach where AI helps brainstorm test cases, but they write the actual test code manually.

Tips for navigating Stage 4

• Develop clear criteria for when to use AI versus traditional coding
• Document both successes and failures objectively
• Start mentoring others in effective AI tool usage
• Regularly review and adjust your AI integration practices

Stage 5: Integration – “This is actually really useful”

Finally, developers reach a balanced and productive relationship with AI tools:

• Seamless integration of AI into existing workflows
• Realistic expectations and efficient usage patterns
• Focus on leveraging AI’s strengths while compensating for its weaknesses
• Ability to teach and guide others through their own adoption journey

Possible examples

A senior developer establishes a workflow where AI is used primarily for specific tasks where it consistently excels: generating boilerplate code, writing unit test templates, and documenting existing functions. For a new API integration project, they use AI to generate the initial interface definitions and basic test cases, but carefully review and modify the output based on their experience and project requirements.

A development team implements ‘AI-assisted code reviews’ where AI tools do the initial pass for common issues and style violations, allowing human reviewers to focus on architecture, security, and business logic. They maintain a shared document of effective prompts and use cases, regularly updated based on team experiences.

Another developer creates a custom VS Code extension that integrates AI assistance into their documentation workflow. When writing comments and documentation, the AI suggests improvements for clarity and completeness, but final edits always go through human review.

Tips for navigating Stage 5

• Create standardised processes for AI tool usage in your workflow
• Develop quality control measures for AI-generated code
• Establish best practices for your team or organisation
• Regularly evaluate new AI capabilities and features
• Contribute to the broader developer community’s understanding – your company, your friends, your network

Conclusion

So, there you have it – the emotional rollercoaster of AI adoption. We’ve all been there, riding the waves of excitement, frustration, and eventual acceptance. Remember, it’s okay to laugh at yourself (and your colleagues) as you navigate these stages. Just keep experimenting, keep learning, and soon enough, you’ll find yourself in a sweet spot where AI becomes your trusty sidekick, not your replacement. And hey, if you catch yourself bargaining with the AI gods for that perfect code snippet, perfect image, or perfect summarisation of data, just remember, you’re not alone! 

Like any model, these stages are not strictly linear – you may move back and forth between stages or experience them differently. The key is to maintain perspective, humour and work toward finding the right balance for your specific needs and context.

Whether you’re just starting your AI journey, or already using AI extensively, embrace the chaos and enjoy the ride. After all, the future of work isn’t about AI vs. Humans – I believe it’s about AI and humans learning to operate together.