Agentic development at DECODE: how we use AI to build software

The question is no longer whether to use AI in software development. It’s how to use it well.

The opportunity is obvious.

Development teams can almost eliminate manual work and get much more done. The hard part is turning that potential into a workflow that actually holds up in real projects.

At DECODE, we’re building AI directly into the way we work.

We use agentic development to speed up execution and make day-to-day delivery more efficient, without lowering the bar on quality.

In this article, we’ll walk you through how we use AI in practice, where it has the biggest impact, and what we’ve learned from bringing it into our software development process.

Let’s dive in!

Planning and discovery: how we use AI to speed up research and planning

Before we build anything, we need to understand what should be built, why it matters, and where the risks are.

That part hasn’t changed.

What has changed is how quickly we can move through the manual side of discovery and planning.

100+ projects delivered. We’re ready for yours. Let’s talk →

You’ll be talking with our technology experts.

We use AI early to build context faster.

That can mean:

• Learning a new industry more quickly. AI can help us get up to speed on an industry we’re less familiar with much faster and help us build enough context to make better early decisions.
• Getting a clearer view of the market. AI helps us build a broader picture of the market, including adjacent products, useful data points, and reference cases we might not find right away.
• Spotting patterns and competitors we might have missed. It can widen the list of relevant competitors and help us notice gaps, overlaps, or common approaches earlier in discovery.
• Identifying recurring themes earlier in the process. That helps us notice the same pain points, needs, or expectations across multiple interviews much sooner.

Instead of spending days collecting and sorting raw material, we can get to a useful starting point much sooner.

We have more time for what matters most: discussing trade-offs, scoping the MVP, and deciding what’s worth building in the first place.

With AI, we can deliver a much more refined MVP. That’s because we can spend a lot more time on the decisions and improvements that lead to better quality instead of on manual work.

Mario Zderic, Co-founder and CTO at DECODE

In other words, during discovery we can almost exclusively focus on strategy.

And that’s essential to building a successful, high-quality software product.

AI is a huge boost when it comes to planning development, too.

We can turn a detailed requirements document into a workable roadmap much faster than before.

On one project, we used AI to turn a requirements document into Jira-ready epics and 400 production-ready tasks. We reviewed and approved the output before moving forward, and in one day completed work that would usually take five.

Boris Plavljanic, Technical Project Manager at DECODE

In short, with AI we can plan development much more effectively.

We spend less energy on repetitive research and admin work, and more on making better decisions before we even start development.

Design: how we use AI to design with more context

With AI, we can design faster without losing context.

A lot of that comes from automating slower, repetitive work at the start of the process.

That gives us more time to test ideas, improve flows, and make better design decisions.

Here’s a couple of examples:

• Generating realistic content from the start. We can use real copy instead of placeholders, which makes it easier to judge layout, hierarchy, empty states, and the overall flow of a screen.
• Catching gaps earlier. AI helps us notice things that are easy to miss on an early pass, like empty states, error states, focus states, disabled buttons, and edge cases in a flow.
• Keeping design systems and patterns more consistent. We can reuse existing patterns more effectively and cut down on the manual work that comes with maintaining a structured design system.

But, the real benefit is that we can focus on decisions that actually improve the UX.

And one the ways we do that is with rapid prototyping.

Instead of spending weeks preparing the first version, we can get real feedback from users and clients in days.

Wireframes are dead. There’s no real need for them when it takes the same effort to get to a high-fidelity prototype, and that prototype is already good enough to test with users, get feedback, and improve it further.

Matej Maric, Product Designer at DECODE

AI has also changed how our designers and developers collaborate.

The line between design and development is becoming much less rigid.

They work in a tighter loop, with much less back-and-forth.

With the Figma MCP, developers can pull a link from our Figma file into their coding agent, update the code, and push those changes back to Figma. It feels like designing through code.

Matej Maric, Product Designer at DECODE

That fits how we already worked at DECODE.

We’ve never isolated design from development. Our designers, PMs, and technical leads have always worked together closely.

AI makes that collaboration faster and easier.

And that’s the real gain.

Development: how we use AI agents to build software

At DECODE, we’ve adopted agentic development.

The idea behind it is simple.

AI agents handle almost all of the operative work, while our engineers stay fully responsible for the plan, the logic, and the final result.

We don’t jump straight into implementation and hope for the best. Agentic development isn’t vibe coding.

We’ve also standardized the tools we use. Instead of everyone using different tools, every engineer gets access to a seat on Claude Code.

This means we can easily share skills and plugins while also standardizing how we work with AI.

But, what does our actual development workflow look like?

AI agents create a first plan for a feature, but we always review, challenge, and improve the output before we generate the code.

Here’s what we look for:

• Weak or missing error handling
• Bad assumptions in the logic
• Inconsistencies with the existing architecture
• Superficial tests
• Code that looks fine, but won’t hold up in production

The biggest change is that our engineers can do repetitive work faster while still keeping full control over the result.

But, what exactly do we mean by repetitive work?

Here are just some of the use cases where AI shines:

• Generating boilerplate code. Agents handle repetitive work that used to take time without adding much value on its own.
• Connecting layers in the architecture. They can help wire parts of the system together and speed up the more routine implementation work.
• Turning payloads into usable classes and models. Instead of doing that structure by structure, we delegate a lot of it and review the result.
• Drafting unit tests alongside feature work. That makes it easier to build testing into our process earlier.
• Summarizing pull requests and technical changes. Technical changes are easier for the team to review and share.
• Pulling in context from tools like Git, Jira, and Figma. We can get the information we need much faster than before.

AI helps us automate a huge amount of repetitive work, sure.

But it also helps our engineers tackle issues they never deal with before, too.

On one project, the client wanted a very specific visual effect. Getting there meant layering colors, opacity, and animation in a way that was new to me. It wasn’t that it was hard, I’d just never built anything like it before. Claude Code knew how to approach it, and that saved me a huge amount of time.

Marko Viskanic, Software Engineering Team Lead at DECODE

In agentic development, coding is no longer a bottleneck.

This means we can be more product-minded and our software engineers are turning into product engineers.

And that’s where our clients really feel the benefit.

Testing: how we use AI to speed up QA

QA has always been a huge part of how we work at DECODE.

That’s still true now.

But what has changed is how much faster we can move through the repetitive parts of QA.

Playwright is one example, but it’s not the only one. Most testing frameworks now come with some form of AI integration. With built-in tools like Codegen, writing automation scripts that used to take 2 hours now takes less than half an hour.

Marko Brajer, QA Team Lead at DECODE

This gives our QA engineers more room to focus on the parts of the job that have the biggest impact on product quality.

We use AI to cut down on manual overhead in areas like automation, bug reporting, test case creation, and documentation:

• Generating test cases from acceptance criteria. Instead of starting from a blank page, we get to a solid first draft faster and spend more time checking whether the coverage is actually meaningful.
• Writing and updating automation scripts. Work that used to take hours takes a fraction of the time, which lets us write and update automated tests much closer to the moment a feature is developed.
• Drafting test strategy documents. We get a usable first version quickly, so we can focus on refining the strategy instead of formatting it.
• Rewriting technical findings into clearer language. That helps us communicate issues more clearly across the team and with clients.

We’ve also built our own AI tools for QA.

One example is our Chrome extension for bug reports.

Instead of filling out every part of a bug report manually, we write a short description and AI builds out the report.

You write two or three sentences describing the bug, and it fills out the rest of the template for you, including the steps, expected behavior, and actual result. That saves us anywhere from 5 to 20 minutes per bug.

Marko Brajer, QA Team Lead at DECODE

Another benefit is that more testing happens in parallel with development, so issues show up earlier and we can respond to them sooner.

We build the feature, add automated coverage right after, and catch issues while the work is still fresh.

That means the gap between development and testing has gotten much smaller.

With that being said, we don’t automate absolutely everything or take AI-generated test cases at face value.

AI can generate a large number of tests very quickly. The important part is making sure those tests actually validate something that matters.

Also, exploratory testing still needs a human touch. It’s where we click through unusual flows, question assumptions, and catch the kinds of issues that won’t show up in a neat script.

And that’s where our QA engineers’ input is most valuable.

Deployment and post-launch support: how we use AI to make releases smoother and ongoing work easier

There’s always a lot work around a new release.

Preparing notes. Summarizing changes. Checking versions. Making sure the team and the client understand what’s going out and what still needs attention.

Instead of collecting information from different places and writing everything from scratch, we now use AI for:

• Release notes. AI helps us pull frontend and backend changes into a solid first draft much sooner.
• Summaries of changes. It helps condense technical updates into something easier to review and share.
• Internal handoff documentation. When the context around a release is already structured and easy to scan, the team has what it needs right away.
• Client-facing updates. AI helps us explain technical changes in a way that’s clear to non-technical clients and stakeholders.
• Maintenance and support tasks after launch. It speeds up the repetitive work around issue triage, summaries, and follow-up.

Releases get smoother because we spend less time collecting and formatting information, and more time actually verifying that everything is accurate, complete, and ready to go.

The same applies after launch.

Post-launch support comes with a lot of routine work: going through logs, reviewing crash data, summarizing issues, and figuring out what needs attention first.

AI helps us get through that work much faster. It can scan large amounts of information, group similar issues, and give us a useful first read right away.

On lower-risk projects, AI takes enough repetitive work off the table that support and maintenance become much easier to manage.

One person can practically run the entire maintenance and support for a less critical project, because AI handles so much of the operative work.

Boris Plavljanic, Technical Project Manager at DECODE

That gives us more room to focus on the work that actually affects the product: fixing important issues, improving what’s already there, and shipping new features.

For our clients, the value is simple.

We spend less time on release admin and repetitive support work, and more time on the work that actually moves the needle after launch.

Looking for an AI-native development partner?

Getting real value from agentic development takes more than trying out new tools.

It takes a team that knows where AI can speed things up, where human judgment still matters, and how to keep quality high as the process evolves.

And at DECODE, that’s exactly how we work.

Our team of senior engineers, designers, QA specialists, and technical PMs uses AI to reduce repetitive work and support better delivery without lowering the bar on quality.

If you’re building a product and want a partner that can combine strong engineering with a practical approach to AI, let’s talk.

We’d love to learn what you’re working on and show you how we can help.