AI has become part of everyday work for many software developers. It can help solve problems in seconds by writing code, explaining documentation or review changes. But using AI effectively isn't simply about getting it to do more work.
For Nicolas Erlichman, our CTO, the most useful way to think about AI is as a collaborative partner. Sometimes it helps him investigate a problem. Sometimes it challenges an idea. And only once the direction is clear, it can take care of the repetitive work.
The important part is knowing which role it should play and when.
From sparring partner to implementation tool
One of the biggest changes in Nico's workflow is what happens before the code gets written. When working with an unfamiliar codebase, for example, it’s useful to use AI almost like a colleague sitting next to you.
Instead of immediately asking it to make a change, you might want to ask:
"Explain how X works before I start modifying it."
From there, AI can help explore documentation, compare approaches, think through possible solutions, and then develop an implementation strategy.
Only after that process could you ask AI to start writing.
This distinction is important. Nico describes AI as a kind of sparring partner during the thinking and planning stage. Once the direction has been established, it can become more like an execution assistant: handling boilerplate implementation work.
The human still decides what needs to happen. AI helps accelerate how it happens.
When AI-generated code creates a new problem
There is a side effect to being able to generate code much faster: there is suddenly much more code to review.
Nico remembers a time when pull requests containing 700-800 lines of changes were already considered large enough to split up. Today, AI-assisted development can easily produce pull requests exceeding 1,500 lines. That creates a problem of its own.
AI can generate code faster than a human can deeply inspect it. And reviewing dozens of large pull requests in a day makes it increasingly difficult to maintain the same level of attention.
This is one reason Nico uses AI for first-pass code reviews. It can help identify potential issues or details that might otherwise slip through before a human performs the final review.
But there is a bigger concern behind this: what happens to the developer's ability to review code critically if they stop understanding how the code works?
The "calculator trap"
Nico compares this to something most of us have experienced with calculators.
A calculator is extremely useful. But if you rely on it for every calculation from the beginning, you may eventually lose the ability (or the confidence) to do basic calculations yourself.
He sees a similar risk with AI and programming; if developers allow AI to write everything from day one, they may become just good at using AI, instead of becoming good at programming. And without that underlying knowledge, it becomes much harder to recognize when AI has produced something inefficient, unnecessarily complicated, or insecure.
For Nico, this is especially important for people who are still learning. That critical human eye matters. His recommendation is simple: learn the fundamentals first, then use AI to accelerate your learning rather than replace it.
Write the code, understand how it works, make mistakes and learn from fixing them. Then let AI help you move faster.
Knowing what not to delegate
There are particular parts of development where Nico deliberately keeps humans completely responsible. One example is empirical testing; AI can always suggest code, but it shouldn’t replace actually running the application, interacting with the product and checking whether the frontend and backend work together as expected.
The same goes for anything involving elevated permissions or core security, it requires careful human review, regardless of who wrote the initial code. AI is useful precisely because it doesn't have to be trusted with everything.
Building your own AI workflow
There are times when the best solution to a big headache is one small problem solved well.
Nico noticed that he was missing important client emails because most of his team primarily communicated through Slack. So using Gmail’s native AI capabilities, he built a small workflow that connects the two.
The system looks through his unread Gmail messages and identifies relevant senders and subjects, sending him a daily summary through Slack. It solves a very specific problem: making sure important information doesn't get lost between communication channels.
Because the workflow does not use any external AI, sensitive email content stays within Google's ecosystem.
For Nico, this is part of the appeal of building custom AI workflows: you can solve a very specific problem while still being intentional about how your data is handled.
Work at maximum speed
Although we think of AI as the fastest problem solving tool, there are times where it just isn't the answer. A developer can spend hours trying different prompts to convince an AI model to solve a bug, when a few minutes of traditional troubleshooting could have solved it much faster.
AI isn’t always the fastest answer; and lets not forget the human side of that.
The fact that we have a tool that makes it possible to be 10 times more productive, doesn't mean we always should. It's easy to start feeling like you should be producing more, but that mindset rapidly translates into pressure.
For Nico, AI should just make work easier. Efficiency is not permanently operating at maximum velocity. There is an unhealthy work expectation that blurs the boundaries between work and rest, creating the idea that developers are always available just because they can be.
So, how should developers use AI?
Our CTO’s approach comes down to a few principles:
- Learn the fundamentals: Understanding the technology you're working with is still essential. AI shouldn't become a substitute for learning.
- Use AI to think, not just to generate: Ask questions, explore alternatives, investigate unfamiliar systems. Use it as a second perspective before asking it to write the solution.
- Keep your critical eye: Faster code generation doesn't eliminate the need for good engineering judgment.
- Build workflows around real problems: Don’t use AIs for no reason. Identify a problem and work around it.
- Find your own pace: AI can accelerate your work, but don't confuse speed with productivity.
AI is changing how software gets built. But perhaps the most valuable skill is actually understanding what work should be delegated, what to keep for yourself, and when to know the difference.
