The Elephant (or Rhino) in the Room: Staring Down the AI Hype
Let’s cut to the chase. The whispers in every virtual stand-up, the subtext of every tech keynote, the existential dread creeping into your late-night coding sessions—it all boils down to one question: Is Artificial Intelligence coming for your job? As a Salesforce Commerce Cloud developer, you’re standing at the intersection of a specialised, high-stakes platform and the most disruptive technological wave of our generation.
The anxiety is palpable, and it’s not unfounded.
But the job of the Rhino Inquisitor is to charge head-first through the fog of fear and hype to uncover the hard, practical truth. So here it is: No, AI is not going to make you obsolete. However, it will, unequivocally, and without mercy, render developers who refuse to adapt obsolete. The threat isn’t the algorithm. It’s atrophy.
This isn’t some far-off future. The shift is already here. The 2024 DORA Report reveals that 76% of developers are already using AI-powered tools in their daily work. A GitHub survey from the same year found that a staggering 97% of developers have used generative AI platforms.
This is no longer an experimental niche… It’s a rapidly adopted standard.
Businesses are (or will go) all-in, with 78% of organisations reporting AI usage in 2024, a massive jump from 55% the previous year. The data is clear: AI is being integrated into the software development lifecycle at a breathtaking pace, promising boosts in productivity, code quality, and even developer focus.
However, the most dangerous misconception is that simply using AI to write code faster automatically translates to greater value. This brings us to a critical, non-obvious threat that developers must understand: the “Vacuum Hypothesis.”
Introduced in the DORA Report, this concept tells us that the time developers save by using AI is often immediately absorbed by lower-value activities, such as endless meetings, bureaucratic red tape, and context-switching between trivial tasks.
Consider this scenario: you use GitHub Copilot to generate a controller with helpers and its test class in 30 minutes, a task that previously took you 90. You’ve just saved an hour. But what happens to that hour? In many organisations, it evaporates into a vacuum of inefficiency. It’s consumed by an extra status update meeting, a flurry of low-priority Slack messages, or simply waiting for a manual, bottlenecked deployment process to inch forward. The micro-level productivity gain is completely nullified by macro-level organisational drag.
This reveals a more profound truth. The most successful developers in this new era won’t just be the ones who master AI tools. They will be the ones who leverage the productivity gains from those tools to focus on high-value work that AI cannot do: architecting complex, scalable systems, mentoring junior developers, collaborating with business stakeholders to solve the right problems, and championing the process improvements needed to ensure that saved time is reinvested, not wasted.
The challenge is as much about changing your organisation’s culture as it is about changing your own code editor.
Déjà Vu All Over Again: A Brief History of Developer "Extinction Events"
The fear that a new technology will render developers obsolete is a story as old as the profession itself (and not just the developer profession). Every major technological leap has been met with predictions of our imminent demise. Yet, each time, the opposite has happened. These “extinction events” were actually elevation events.
They were moments of abstraction that, rather than replacing developers, freed them from tedious, low-level tasks to tackle problems of ever-increasing complexity and scale. AI is simply the latest, and most powerful, chapter in this long-running story.
The Compiler Revolution (1950s-1960s): From Machine Whisperer to System Architect
In the pioneering days of computing, programming was a tedious and painstaking process. Developers wrote instructions directly in binary or low-level assembly code, a process that required an intimate, almost mystical, understanding of the machine’s hardware. Then came the compiler. Tools like FORTRAN and COBOL introduced high-level languages that allowed programmers to write in a more human-readable syntax. The compiler would then automate the translation of this code into the ones and zeros the machine understood.
The “threat” was obvious: what would happen to the programmers who had spent years mastering the intricacies of machine code? Would this automation make them redundant?
The reality was transformative. The compiler abstracted away the hardware, freeing developers from the tyranny of the machine. This single innovation gave birth to the entire discipline of software engineering. Instead of focusing on managing memory registers, developers could now focus on designing algorithms, data structures, and complex application logic. The scope of what was possible exploded.
The programmer evolved from a machine whisperer into a system architect.
The IDE Takeover (1990s-2000s): From Code Typist to Supercharged Problem-Solver
For decades, a developer’s toolkit was a fragmented collection of disparate programs: a text editor, a separate compiler, a command-line debugger, and build scripts. Then came the Integrated Development Environment (IDE), which bundled all these tools into a single, cohesive application.
The “threat” was one of deskilling. With features like syntax highlighting, intelligent code completion, one-click debugging, and integrated version control, the IDE automated dozens of small, manual tasks that were once the hallmark of a seasoned developer’s workflow. Would this “dumbing down” of the process reduce the value of experienced programmers?
The reality was a massive leap in productivity. Studies have shown that IDEs can boost developer productivity by up to 30% and significantly reduce debugging time. By abstracting the workflow, the IDE allowed developers to navigate and manage enormous, complex codebases with unprecedented ease. This efficiency gain was essential for building the large-scale, distributed web applications that came to define the internet age. The developer was no longer just a code typist; they were a supercharged problem-solver, wielding a powerful, integrated toolset to build more, faster.
The Agile & DevOps Movement (2000s-2010s): From Siloed Coder to Value Stream Owner
The final major shift came not from a tool, but from a philosophy. The Waterfall model, with its rigid, sequential phases, was too slow and inflexible for the fast-paced world of web software. The Agile and DevOps movements proposed a new way of working, emphasising iterative development, cross-functional collaboration, and the automation of the entire release pipeline through practices like Continuous Integration and Continuous Delivery (CI/CD).
The “threat” was a blurring of roles. If deployment and operations were automated, what was the primary function of the developer?
The reality was an expansion of responsibility. The developer’s role grew to encompass the entire software lifecycle, from ideation and coding to deployment, monitoring, and maintenance. They were no longer just writing code in a silo; they were owners of a value stream, responsible for delivering tangible business outcomes quickly and reliably.
This history reveals an undeniable pattern: every wave of automation and abstraction has elevated the role of the developer, pushing them to operate at a higher level of strategic thinking.
However, there is one crucial difference this time around.
The pace of change is accelerating at an exponential rate. The transition from machine code to high-level languages took the better part of a decade. The widespread adoption of generative AI coding assistants has occurred in less than three years.
This compressed timeline means that the ability to learn and adapt is no longer just a valuable trait; it is the single most critical survival skill. A “wait and see” approach is a guaranteed strategy for obsolescence. The skill gap between those who adopt these tools and those who do not will widen more rapidly than in any previous technological shift.
The AI-Augmented Rhino: Your SFCC Developer Arsenal in 2025
Theory and history are comforting, but survival requires a practical arsenal. For the SFCC developer, this means moving beyond abstract notions of “using AI” and mastering a specific set of tools and techniques. This is how you transform from a potential victim of disruption into an AI-augmented rhino, capable of charging through complexity and delivering value at an unprecedented speed.
Your AI Pair Programmer: Code Generation and Assistance
The most immediate and tangible application of AI in our profession as developers, is in the act of writing code.
These tools are not just fancy autocompletes… They are context-aware partners that can drastically reduce the time spent on repetitive, boilerplate tasks.
GitHub Copilot for SFCC
GitHub Copilot is the de facto (ok … this is debatable – but replace GitHub Copilot with your favourite) standard for AI-assisted coding, and its capabilities extend deep into the ecosystem.
Because it was trained on countless public GitHub repositories, it has a surprisingly robust understanding of React.js, OCAPI and SCAPI structures.
ChatGPT and LLMs for Strategic Development
Large Language Models (LLMs) like ChatGPT, Claude, and Gemini are your strategic partners. Using them effectively requires a new core competency: Prompt Engineering.
This is the art and science of crafting instructions that guide the AI to produce the desired output. Key principles include:
Role Prompting: Begin your prompt by assigning a persona. “Act as a senior SFCC technical architect with 15 years of experience in high-volume retail.” This frames the AI’s knowledge and response style.
Providing Context: Give the AI all the relevant background. Paste in existing code, business requirements, or error messages.
Using Delimiters: Clearly separate your instructions from the data you provide using markers like triple backticks (“`) or XML tags.
Armed with these techniques, you can use LLMs for high-level tasks that go far beyond simple code generation :
Architectural Brainstorming: “I need to build a custom ‘Quick Order’ feature on an SFCC PWA Kit store. Provide me with three different technical approaches for comparison: the use of a custom SCAPI endpoint, a server-side SFCC controller with a traditional form post, and a standard SCAPI endpoint. Analyse the pros and cons of each regarding performance, scalability, and development effort.”
Legacy Code Archaeology: “Here is a legacy SFCC pipelet script from a SiteGenesis implementation. Explain what it does, identify its inputs and outputs, and highlight potential points of failure or performance bottlenecks.”
Documentation on Demand: “Generate a JSDoc comment block for the following JavaScript method, explaining its parameters, return value, and purpose.”
Test Plan Generation: “Create a comprehensive test plan for an e-commerce checkout flow. Include test cases for different payment methods (credit card, PayPal), shipping options, guest vs. registered user checkout, and handling of invalid coupon codes. Here is a description of all the steps in our checkout process: …”
Your AI QA Engineer: Smarter Testing & Debugging
Debugging and testing are two of the most time-consuming aspects of development, especially within the complex, interconnected systems of SFCC.
AI is poised to revolutionise this space, acting as a tireless QA engineer that can catch issues before they ever reach a human reviewer.Tools like Qodo AI (formerly CodiumAI) can analyse your code and automatically generate meaningful unit tests, covering edge cases you might have missed. For debugging, Workik offers context-aware analysis, allowing you to provide error messages and relevant code snippets to receive intelligent, plain-English explanations of the root cause. More advanced tools even allow you to have a conversation with your debugger, asking questions like, “Why is this orderTotal variable null at this point in the execution?”
For an SFCC developer, this means a future where the soul-crushing task of writing boilerplate test data setup is automated.
It means pasting a cryptic NullPointerException stack trace into an AI tool and getting back a precise explanation and a suggested fix.
It means integrating security scanners like SnykCode directly into your IDE to flag vulnerabilities in your custom code in real-time, long before a pull request is ever created.
This isn’t about replacing QA. It’s about augmenting it, freeing up human testers to focus on complex user experience issues and business logic validation.
The Evolved Developer: More Than a Coder, a Creator
The rise of AI marks a fundamental shift in the value proposition of a software developer. When the act of writing code—the “how”—is increasingly automated, the most valuable professionals will be those who have mastered the “why.” Your worth will be measured not by your typing speed, but by the quality of your thinking.
The Architect's Mindset: Your Most Valuable Asset
As AI dramatically lowers the barrier to implementation, the relative importance of high-quality system design, clear interface definitions, and robust architectural boundaries skyrockets. A poorly architected system, even if coded flawlessly and instantly by an AI, is still a poorly architected system. It will be brittle, difficult to maintain, and unable to scale.
The SFCC developer of the future adds value long before the first line of AI-generated code is produced. Your expertise is no longer demonstrated by your ability to write a perfect for loop in ISML script. It is shown in your ability to analyse a business requirement and make critical architectural decisions.
Can this new requirement be leveraged using out-of-the-box features, or should we write a custom controller that utilises the existing SFRA framework?
Should this feature use custom objects or custom caches?
Is it a candidate for a third-party API integration? Or can the business goal be met more effectively by leveraging a native feature?
This is the architect’s mindset. It’s about understanding the entire ecosystem—the platform’s capabilities, the available APIs, the business goals, and the long-term maintenance implications—and charting the most effective course. This strategic thinking is a uniquely human skill that AI, in its current form, cannot replicate.
"Soft" Skills are Now Hard, Non-Negotiable Technical Skills
For too long, the industry has dismissed crucial human-centric abilities as “soft skills,” implying they are secondary to “hard” technical prowess. In the age of AI, this distinction is becoming dangerously obsolete. These skills are now core, non-negotiable competencies for any effective technical professional.
The logic is straightforward. AI can generate code, but that code can be buggy, inefficient, or insecure. This phenomenon has been dubbed “implementation amnesia,” where developers become dependent on AI suggestions without building a deep mental model of the systems they create. Therefore, a developer needs Critical Thinking to rigorously evaluate, question, and refine the AI’s output. This is not a soft skill – it is a fundamental technical requirement for ensuring quality.
Similarly, AI requires clear, unambiguous, and context-rich instructions to generate valuable results. Therefore, a developer needs exceptional Communication and Prompting skills to translate complex business requirements into instructions the AI can understand and execute. This is a technical skill of the highest order.
Ultimately, AI addresses technical issues, but businesses tackle human-centric problems. AI cannot understand a user’s frustration with a clunky checkout process or empathise with a merchant’s need to hit a quarterly sales target. Therefore, a developer needs Collaboration and Empathy to work with stakeholders, understand their actual needs, and define the correct problems for the AI to solve in the first place.
These are not optional niceties… they are business-critical technical skills that determine whether a project succeeds or fails.
Conclusion: Be the Rhino, Not the Dodo
It's possible that AI might encounter a roadblock within the next two years - a plateau that the current technology can't yet overcome - but I don't have a crystal ball, do you?
The history of software development is a history of abstraction. Each new layer, from the compiler to the IDE to the cloud, has eliminated a class of manual labour and, in doing so, has empowered developers to build things that were previously unimaginable. Generative AI is the most profound abstraction layer we have ever witnessed. It is abstracting the very act of writing code itself.
This is not a cause for fear! It is a cause for action.
It does not make you obsolete; it gives you unprecedented leverage. The developers who face extinction are those who cling to the past, defining their value by the tasks that AI can now do better and faster. They are the dodos of this new era, unable to adapt to a changing environment.
The developers who thrive will be the ones who are like rhinos. They will see AI not as a competitor, but as a powerful partner that frees them from the mundane and empowers them to focus on the work that truly matters: creativity, strategic thinking, complex problem-solving, and human collaboration.
The future of the SFCC developer is not that of a simple coder, but of a technical leader, a system architect, and a strategic problem solver. The path forward is clear, but the window of opportunity to adapt is closing faster than ever before.
Please don’t wait. The time for passive observation is over.
Get your hands dirty, now. If you don’t have a GitHub Copilot license, buy one this week. The $10 per month is the single best investment you can make in your career. (For your projects, customer/company code is a bit trickier on the legalities)
Experiment relentlessly with prompts. Take a piece of your own code and ask Copilot to refactor it, explain it, or find bugs in it. Learn the language of AI.
The future isn’t something that happens to you; it’s something that you create. It’s something you build. Stop worrying about being replaced. Pick up the tools, sharpen your horn, and become the AI-augmented rhino that leads the charge.
