Code assistants: AI’s role in modernizing software craftsmanship

For decades, software development has been defined by craftsmanship. Yet, let’s face facts: we’re still in the stone age of our discipline. Each line of code is meticulously written by hand, a practice as old as the industry itself. Compared to other engineering fields, software is in its infancy. And it makes sense: civil and mechanical engineering, for example, have centuries of evolution behind them; software engineering is barely a few decades in.

We tend to see ourselves as pioneers at the technological frontier, which is true, but at the same time our work is quite artisanal. It’s too handcrafted. We developers often take pride in this hands-on approach, finding satisfaction not just in solving complex puzzles, but also in the simpler tasks that senior engineers can solve with their eyes closed: coding a button, setting up endpoints, configuring state management. There’s joy in those tasks too, I’ve been there and I understand that.

Since I started coding professionally more than 26 years ago, many things have changed: languages, devices, ways users interact with apps. However, the concept of building software manually, brick by brick, still remains the same. But let’s be honest: writing every line of an application by hand is an outdated practice, no matter how much we enjoy it.

So, Generative AI appeared in the scene, and it’s challenging our lifelong practices. In an industry as handcrafted as ours, disruption is only natural. The rise of AI-powered code assistants is impulsing a transformation similar in some ways to the Industrial Revolution. How we build software is being fundamentally reshaped, and also, how we deliver value. The time has come to embrace this change.

From artisan to automation

Picture a master woodworker crafting an armchair. He sketches, selects the finest wood, shapes each piece by hand, and assembles the parts with care. The result is more than a unique piece of furniture: in some way, the woodworker’s soul is embedded in it. And, as romantic as that sounds, software developers often feel the same about their code.

But not every room needs a costly bespoke armchair. Sometimes, you just need a place to sit, and a mass-produced chair will do the job. Similarly, not every piece of code should demand hours of attention. Not every challenge merits a craftsman’s touch.

Historically, a significant portion of a developer’s workload has been consumed by tasks that are essential for digital products, but not really the engine of business growth. For example:

• Implementing authentication and authorization
• Setting up API endpoints
• Handing global errors
• Configuring environment variables
• Creating base components
• Unit testing
• Documenting
• … you name it.

Take microservices as an example. Backend developers spend countless hours setting up the basic structure for new microservices: configuring endpoints, setting up authentication, wiring up logging, implementing resilience strategies. These steps are non-negotiable for a robust microservice, but they are repetitive and consume plenty of time. In organizations running dozens of microservices, this repetition multiplies. Code assistants can now generate much of this boilerplate in seconds, freeing backend developers to focus on the logic that truly makes the microservice useful.

On the frontend, the story is much the same. Building forms, for example (handling input validation, error messaging, state), has long been a repetitive grind. Even with libraries, much of the work remained manual. Today, code assistants can generate the foundational code for these forms, and frontend developers can concentrate on user-centric features that drive engagement and retention.

I could go on. For every developer role, there’s a mountain of repetitive work that can be automated.

Code assistants, trained on millions of codebases, excel at automating what’s been done a thousand times before. What they’re not great at (at least not out-of-the-box) is solving novel, complex problems that demand creativity and deep reasoning. That’s where human expertise shines. And that’s why senior developers are embracing these tools: they finally get to focus on what truly matters, leaving the repetitive tasks behind.

The Industrial Revolution of software

But what happens when an industry built on craftsmanship meets the power of automation?

To appreciate the magnitude of this change, let’s draw a parallel to other professions. Accountants once relied on teams of human calculators, a role rendered obsolete by the spreadsheet. Legal teams have evolved too: junior lawyers once spent hours combing through endless books for precedent, but today’s research is accelerated by digital search tools. Software development is now experiencing its own transformation.

During the Industrial Revolution, artisans who once crafted goods by hand had to adapt, learning to operate, maintain, or even design the very machines that replaced their old ways of working. Likewise, today’s code assistants automate the repetitive work that used to define much of a developer’s day.

Development teams that leverage code assistants are saving hours and hours of work, even when their output is not perfect and still requires some refinement. Here are only a few recent examples from our developers at CloudX:

• One of our engineers used Cursor to assist in migrating a project’s Java codebase from version 11 to 21, reducing the time required by 98%. Yes, ninety eight percent. What two years ago took 120 hours (three weeks of a senior engineer’s time), was accomplished in just 2 hours.
• Another developer used Copilot to implement robust authorization handlers with role-based filters in a .NET API. What once took 2-3 hours of manual coding was accomplished in a matter of minutes.
• In another case, a team member used a coding assistant to streamline unit test setup, dramatically reducing the reliance on repetitive patterns and achieving a 75% reduction in time spent on test configuration.

The message is clear: code assistants enable teams to tackle both essential work that used to take weeks, and also important tasks that previously fell out of scope due to time constraints (such as unit tests, technology migrations, simple refactors). This doesn’t mean that now developers have free time: it means their profession is more efficient than ever, delivering higher-quality digital products, faster.

The future of software development

Of course, no revolution comes without its share of challenges. As with the first machines in the factory, there are understandable concerns about job displacement, skill gaps, and the uncertainty that comes with rapid change. But history teaches us that the nature of work evolves. Repetitive, physically demanding tasks gave way to roles that require oversight, creativity, and strategic thinking.

AI’s impact on software development is profound, marking the end of an artisanal era and the beginning of a new age of automation. My advice to software engineers and companies alike: learn to harness AI, embrace the change, and you’ll soon see the results.

Human ingenuity remains irreplaceable when it comes to truly novel or business-critical challenges. History shows that automation does not diminish the value of skilled professionals. It amplifies it. Spreadsheets didn’t eliminate accountants; they empowered them to focus on analysis and strategy. Search engines didn’t make lawyers obsolete; they optimized legal research, freeing up time for higher-value work. The same is happening in software: code assistants are creating space for developers to upskill, specialize, and focus on more interesting and valuable challenges. The disruption is real, but so is the opportunity: developers embracing these new tools find themselves empowered, not replaced.

There’s no need for fear. As the world still needs accountants and lawyers, it will continue to need developers. Only that the role as we know it will evolve. We’re still in the prehistory of the digital age. Everything is still to be done.