Last weekend, I spent some time testing various AI coding tools and platforms. Claude Code and Windsurf turned out to be the most impressive — and surprisingly complementary — contenders.

What we're experiencing is nothing short of a revolution in software engineering. The traditional role of a software engineer is undergoing a profound transformation, and to stay relevant, we must adapt. Here is a 2 part article on the topic.

The first part talks about the current state and the second about the impact on the role of software engineer.

The state of AI for SWE

AI coding assistants have evolved from simple auto-completers to powerful tools that understand context, enforce patterns, and generate high-quality code at scale. Let me share with you where I found it to 1. allow you do things 10x faster 2. allow you to write better code 3. where it falls short.

What AI allows you to do things 10x faster

This bucket is straightforward and the first one you should embrace as an organization. At present, we have embraced it and therefore put software engineers on steroids.

Anything that is repetitive can be streamlined by AI. Any repetitive coding pattern, like a backend module writing CRUD like interfaces that you then tweak to add business logic is an amazing place to use AI. Another example applied to Data Engineering: one step of a data pipeline process is the standardization of the raw data: rename fields, order them to make the table easily readable, type casting etc... When you want to standardize a lot of tables from the same source, it can be very long. These tasks are important but very repetitive, boring and time-consuming. With AI it's much faster, and also the results are more consistently. Testing is another area where AI should be leveraged much more.Writing tests is tedious and repetitive, but relatively easy to do. This makes considering the TDD more relevant than ever, especially as AI is writing more code and testing better becomes a necessity.

Where AI makes you not just a faster engineer but truly a better one

This part is where AI is really unleashed and where I was impressed the most.

• Naming variables: When naming variables, one should not try to be super inventive. On the opposite, we should stick to simple, an original name. Selecting a variables and asking AI for a better alternative makes wonder and increases the quality and readability of your code. It still requires self awareness that your current naming may not be the best.
• Writing Commits: Claude does wonders at using the git and github cli to write commits. I now just write the code. When I am happy with the diff, I just Git reset main and ask Claude to write a good commit history. It writes better PRs than I do and makes my reviewers day better. Eliminates spelling errors in comments and documentation for a cleaner, more professional codebase.
• Debugging: Interacting with Claude and asking it to help you debug is super impressive. At present, we have what has become a Spaghetti NestJS backend architecture. Faced with a circular dependency injection problem in NestJS, I asked Claude to help me with that. It successfully pin pointed the right a missing link in code that is otherwise hard to untangle for a human eye.
• Get some expert consultancy: I kept pushing the limits when following up on the bug above, I asked Claude to help me write a design doc to reorganize the modules to remove that circular dependency. It made great suggestions, including great naming suggestions. The level of insight that he gave me was the one of a great senior software engineer with many years of experience working on this kind of problem. Mind blowing!
• The condition for Claude to be a great tool to ping pong with is to have a well formalized problem with already some ideas of where you want to go. One could argue that with that done, half the problem is already solved. True But Claude and Helping You With That Second Half Is No Small Feat.

Where It Falls Short

• Frontend: Frontend development turned out to be much more challenging. I set up a figma MCP and was hoping to streamline the design system implementation. I felt short succeeding in that. Frontend complexity just seems too much for now.
• In software engineering, there are notoriously many many different ways of achieving the same things. Very often, there are no one better choice but there are probably better choices for your team depending on the product your building, your team, and so many other parameters. Defining those patterns is definitely not something the AI can do. If you let AI do that, your code will soon enough be a Frankenstein monster making it totally impossible to evolve. Setting up the right guardrails and patterns is what one needs to be super cautious about.
• And of course, there is a tone of product thought that is part of the role of a software engineer. Understanding your personas, refining your flows, designing and prioritizing the right feature are not things AI can do today.
• Good news, there are still many many places where us human clear thinkers outpace AI by a lot. Notoriously, we have critical thinking.

The Next Things I Would Want to Try

Testing those tools made me want to continue to dive deeper. Here are some things that I would want to explore:

• Better and better prompt and instructions. I could probably push the limit of what I was able to do by spending more efforts in defining better prompts and pointing the AI to example file that it should use as example for architecture.
• Pre commit hook that goes through the modified code and automatically checks if there are better variable names for newly defined variables
• Prompt engineering and Claude action to write commit history according to team pattern (cf writing commit paragraph)

The New Software Engineer:

What's an AI powered software engineer

In the age of AI coding assistants, the role of software engineers is undergoing a profound transformation. To remain relevant and effective, we must shift our focus to high-value activities while leveraging AI for repetitive tasks. Here's how the modern software engineer's role is evolving:

1. Defining Patterns and Engineering Prompts

First and foremost, the role of a software engineer should be the one of an architect. Software engineer should keep doing what they have always done

• Selecting the best frameworks and libraries for their usecades
• Setting rules and creating exemplary code that establishes standards
• Implementing testing frameworks and coding patterns

Engineers should probably think without too much AI assistance to limit bias. Staying on top of the new stuff requires consuming content from YouTube, blogs, and other resources to integrate combined technologies and relevant coding practices.

In the same way that an architect must adapt to innovation in materials (think about Le Corbusier and concrete), architecting code must be compatible to take the most out of AI. Architectural patterns should be designed with AI in mind. Key principles include:

• Consistent, intuitive naming of files and variables
• Logical colocation of related components
• Stay extra simple

The goal of this is to be able to configure and fine-tuning AI assistants like Claude Code or Cursor/Windsurf so that they can enforce the predefined rules. An AI era software engineer should develop expertise in prompt engineering to effectively “program” the AI. Pairing tool capabilities with good configuration - prompt engineering - will make sure patterns are enforced drastically increasing the quality of a codebase.

2. Specification Writing

Once your AI IDE are well configured, let's move forward with actually implementing features. What does it take to do that with AI. The translation of ideas into implementable requirements involves:

• Writing precise, detailed specifications that
  • Be as Precise in That Definition While Letting the AI Do the Heavy Lifting
  • Crafting bullet-point requirements that AI can transform into functional code. Typically the AI can create one commit per bullet point
  • Identifying edge cases
• Defining acceptance criteria that AI-generated code must satisfy

Then, this can be sent to an AI that will write a draft PR. For simple tickets, it will do the job perfectly the first time, more complex tickets will likely require tweaking.

3. Iterating with the AI to refine code writing

For more complex tasks that require iteration and tweaking, software engineer should regain control. It is still unclear how this will unfold but I see two ways this can happen:

1. Interacting with the AI though PR and code review. Typically, one would write a review on github, commit by commit, and the AI would adapt the patch and answer the comment
2. Actually writing code, after the AI has crafted a draft PR. Being a git wizard will probably be part of the cheat code for this. You might want to just classically fetch the PR locally, edit a specific commit and push modifications back. That's what is most accessible today.

4. Code Review and Quality Assurance

The validation layer ensures quality, functionality, and scalability — and is becoming even more important. Other the last years, there was a tendency to put more burden on the dev and less on the review, especially in senior teams. This trend will be the other way around. This is both critical and super hard in an AI era where going against what the AI has written requires a tone of critical thinking. AI system have this capacity to present things that are “wrong” in a way that always looks “right. With AI generating more of our code, testing becomes more critical than ever.

The typical flow of writing code in a few months/years from now:

• Product/Design/Engineer work together and iterate on writing a ticket
• A software engineer writes ticket specs that are good for an AI to take on.
• Once ready, a tag is assigned to the ticket.
• The AI gets this trigger. Code is generated is a PR is created.
• Engineer iterate with the AI/by themselves.
• The ticket goes through a typical code review process and is merged.
• For all of this to work, there is definitely a level of piping and automation that will need to be handled by an engineering team. This includes the right CI/CD pipeline and tool automation that are connected. That's another place where good old software engineering architect skills and understanding will be needed

The Implications for Individuals: A Rising Bar

The rise of AI coding tools is dramatically reshaping both the skills required of engineers and the career progression for those entering the field. The implications are particularly significant for early-career professionals. The level of critical thinking needed to be a valuable software engineer is reaching new heights. Engineers must now:

• Evaluate AI-generated solutions with a discerning eye
• Understand system design at a deeper level to effectively guide AI
• Develop stronger analytical skills to identify when AI solutions fall short
• Possess the judgment to know when to use AI and when human coding is preferable
• Be especially strong at defining patterns and prompts, as discussed earlier

Thinking that AI can turn a B-level SWE into an A-level SWE is a pipe dream. AI is a force to multiply, not an enhancer.

The traditional path for junior engineers is therefore being disrupted. Routine coding tasks - once the training ground for beginners - are increasingly handled by AI. The days of learning through years of routine implementation are vanishing, replaced by a steep learning curve that demands higher-order thinking from the start. This shift means that the bar for junior engineers is just much higher.

Merging of roles

The boundaries between design, product management, and software engineering are blurring.The role of a software engineering was previously focused on coding ability. As we have seen before, it is now only part of the job.AI is squeezing the value of the software engineer. Downstream, it's automating coding; upstream, it's democratizing it. Upstream, Product Managers can today prototype and solve easy bugs and tomorrow directly implement features into the codebase.

Therefore, software engineers must bring more value and will naturally expand towards what product managers have been doing. These previously distinct roles will probably converge into a unified function where, technical expertise meets product vision and engineering knowledge shapes product strategy.

Conclusion

As we transition from typing every line of code to orchestrating AI-powered systems, software engineering value shifts toward architectural thinking, pattern definition, and quality control.

This evolution requires new skills: prompt engineering, effective specification writing, and heightened critical judgment. The most successful engineers won't be those who code fastest, but those who can establish clear patterns, communicate precisely, and guide AI tools toward optimal solutions.

Organizations that adapt to this shift early will gain tremendous advantages in development speed and code quality. They'll build more reliable software faster, with fewer resources.

For individual engineers, this transformation represents both challenge and opportunity. The AI coding revolution isn't eliminating software engineering roles - it's transforming them. Those who can adapt, develop their critical thinking skills, and position themselves at the intersection of human creativity and AI capabilities will become not 10x but 100x engineers.

At Ditto, we are embracing those new ways of working. We have just been scratching the surface and the potential for significantly transforming how and at which pace we are building product is huge. I can't wait to implement things we have just talked about at scale.

What an exciting time to build software products!

NB: Thanks Alexis B. for the review and ideas! NB2: If this vision of software engineering sounds like music in your ears, contact us to apply to our SWE roles ⇒ etienne@trustditto.com

‍