Inside Attico’s AI agent technology stack

This article explores Attico’s AI agent technology stack and covers how AI agents reduce development time and costs.

Sep 25, 2026 12 min read

Introduction

The growing use of AI in software development has become one of the most obvious trends in recent years. Today, AI is no longer seen simply as a tool for writing code. It can be used across virtually every stage of the software development life cycle (SDLC) — from gathering and analyzing requirements and working through the architecture to validating requirements for testability, implementation, testing, and production deployment.

AI can also support the processes around development, such as handling support tickets, routing tasks, preparing reports, and planning.

That’s why we, the Attico’s team, decided to take a closer look at how AI can be used across different stages of Drupal website development — our core area of expertise.

There’s been a lot of hype around AI for several years, but its capabilities in software development used to be much more limited. It could handle relatively simple tasks and build projects from scratch, but the output usually required a significant amount of manual work, especially as projects became more complex.

The technology has matured, and AI can now be treated as a practical engineering tool for handling real-world development tasks.

Our team didn’t have one specific problem that needed an urgent solution. Instead, we started with a business hypothesis. Usually clients want more functionality, delivered faster and at a lower cost. And one of the key hypotheses around AI is that it can help speed up development while reducing costs.

So, in part, we built our own system to test that hypothesis in practice.

Why do AI agent harnesses need additional layers?

There are already a number of AI agent harnesses on the market — development environments designed to help engineers work with AI. They take different approaches, but generally provide the basic capabilities needed to produce a good-quality result.

The challenge is that these tools are generally designed for a broad audience — developers or so-called vibe coders who are comfortable experimenting, making manual corrections, and constantly monitoring the AI’s work. Enterprise development has different requirements: we need reliability, predictability, and consistent, repeatable results that we can stand behind and be accountable for to our clients.

That’s why our specialists build on top of existing AI agent harnesses with our own layer of agents, skills, commands, configurations, and additional scripts. This gives us more control over the process, making it more reliable, and allows us to generate code and build production-grade solutions via AI.

Is Drupal a good fit for AI-assisted development?

Drupal is a strong fit for AI development thanks to its architecture and mature best practices.

Reliable, performant, and secure solutions in Drupal are built using a limited number of proven methods. This gives AI a clear framework to work within, making its output more predictable and consistently high-quality.

Another advantage is Configuration Management. Drupal stores its configuration in YAML files, so AI can work with configuration as well as code and produce a reproducible setup that can then be applied to the system in a predictable way.

There’s also a dedicated AI initiative within the Drupal ecosystem focused on integrating Drupal with different AI providers. It already includes a number of ready-made components, including skills and MCP servers. We don’t have to build everything from scratch — our specialists can reduce development time, using and extending what’s already available.

Agent system structure and evaluation

The system consists of three main parts: skills and agents, a dataset of real-world cases, and AI Agent Inspector.

Skills and agents

The skills cover areas such as backend, frontend, and Cypress end-to-end autotests, and are selected based on the context of the task. Agents handle specific roles, including development, code review, security review, and other checks.

Tools and infrastructure

The workflow is built on OpenGSD, while the system itself is not tied to any particular AI tool and can work with different CLIs. Third-party tools such as Inspect AI, Docker, PHPCS, PHPStan, Gitleaks, ESLint, and Stylelint provide the underlying infrastructure. Our team develops and maintains the Drupal-specific layer, including the skills, test cases, evaluation logic, integrations, and CI/CD.

AI Agent Inspector

We evaluate quality using real tasks from our own repositories. AI Agent Inspector is the internal tool we built to make that process repeatable. It starts with the project in its pre-change state, runs the agent in an isolated environment, and then compares the result with a reference solution. Straightforward things are checked with static analysis tools, while more complex aspects are evaluated using a calibrated LLM-as-a-judge.

Our specialists pin the versions of the skills, dataset, and evaluation setup, and run each case multiple times to account for AI’s non-deterministic behavior. We measure quality, consistency, and execution time, keep the data from every run, and can compare different system versions, models, and CLIs. This lets us track not only improvements but also regressions, and develop the system in a controlled way for production use.

Implementing AI into the development workflow

The overall task lifecycle stays the same: a task comes in from the tracker, goes through development, review, testing, and release. AI is integrated into the development stage: it gets the task and the relevant project context, automatically selects the skills it needs, creates an implementation plan, and, once the plan is approved, writes the code and Drupal configuration.

Additional agents can be used for code review, security review, and secret scanning. AI works best on well-defined, repeatable tasks with clear examples. For more complex planning, we use more capable models because the quality of the plan directly affects the quality of the implementation.

The developer remains in control at key points: providing the relevant context, reviewing the plan, setting boundaries for acceptable solutions, and validating the final result. After the agent finishes its work, the developer always reviews the code, runs it, and checks the key scenarios and smoke tests. Project-specific context is stored separately from the general skills and can be reused across tasks and shared with the rest of the team using Git to avoid AI studying the project again and again, and therefore reduce token usage. The developer can stop or adjust the agent at any point, and final responsibility for the quality of the result always remains with the developer.

AI-assisted development adoption at Attico

At the time of this article publication, the agent stack has been in use for about 3 months. For the first month and a half, we developed and tested it within our research and development (R&D) team, using it on real-world tasks and gathering feedback from developers. Once we saw clear gains in productivity and that it could handle more complex and unfamiliar types of tasks effectively, the team started rolling it out to client projects.

The system is now running on two projects. Several backend and frontend developers are participating in the pilot, with a dedicated channel for collecting their feedback. In parallel, the R&D team is testing the system for automated testing, with plans to scale this area in the near future.

Results of AI implementation

At this stage, we’re already seeing a noticeable reduction in development time. For example, one task that took a developer 16 hours without a successful result was completed with AI in just 3 hours. In another case, the time needed for a typical task was cut from 4 hours to 2. Based on feedback from some developers, even after accounting for context preparation, plan review, and code review, working with AI can be around three times faster than developing manually.

At the same time, AI often doesn’t provide much benefit for small, one-hour tasks. The time spent providing context and reviewing the plan and the result can be comparable to the time it would take to just do the task manually.

AI has also worked well for larger technical changes. We used it to migrate a project from Storybook 8 to 10 and from Tailwind 3 to Tailwind 4. The latter upgrade affected a lot of frontend components, and doing it without AI would have taken considerably more time.

The experiment has shown us which skills we need to develop further. The main one is context management: developers need to know how to frame tasks for AI effectively and how to review and control the results. That’s why, alongside R&D and knowledge sharing, we’re also focusing on creating training materials and systematically onboarding the team to this way of working.

Developer feedback on working with AI

Our team hasn’t had any major issues with the code. A lot depends on choosing the right model and making sure its capabilities match the complexity of the task.

Strengths	Weaknesses
“With AI, the focus shifts to planning and understanding from the start what needs to be done and how it should be implemented”	“AI adds unnecessary comments”
“If it’s something new and you need to read through the docs and keep switching between things, doing it manually can easily take three times longer than working with AI”	“It doesn’t remove unused code”
“Clean, easy-to-understand code”	“The plans can be quite long and sometimes hard to read and follow”
“The code passes linting checks and follows coding standards”	“On larger tasks, weaker models tend to hallucinate”
“The logic is correct”	“The biggest challenges are framing the request clearly and choosing the right model”
“AI can analyze the page on its own and identify the classes and attributes needed to write automated tests. This saves a lot of time that would otherwise be spent finding them and adding them to the test code”

Conclusions and takeaways

This is still just the beginning, but the main hypotheses have already received initial validation: using AI can speed up development and reduce costs. This is the key result that provides a basis for scaling the system further.

We also found that small tasks that take around an hour usually aren’t worth delegating to AI — the time spent providing context and reviewing the result can be comparable to doing the work manually.

Another important takeaway is that developers need a structured onboarding process — not just general guidance on working with AI, but also practical materials on prompting, context management, and common issues.

That’s why our team has made two decisions: to expand the use of the system across projects and continue improving it, increasing the quality of its output and gradually covering more stages of the SDLC.

Further evolution of the AI agent stack

Attico is currently developing the system in two directions: expanding the overall workflow and improving the quality of the output, with the goal of reducing the amount of manual correction developers need to do.

To do this, we use a loop engineering approach, structuring the process as a series of cycles where each artifact is created and then reviewed. In traditional development, requirements, architectural decisions, and code go through reviews of varying levels of formality — from a quick discussion between developers to a detailed review by a mentor. We’re applying the same principle to AI.

For example, one agent creates the implementation plan, while another reviews it against a defined set of criteria. There’s a minimum score to pass, along with a set of mandatory requirements. If they aren’t met, the plan is automatically sent back for revision — either until it reaches the required quality level or the maximum number of iterations is reached. Only then is the result passed on to the developer.

This helps ensure upfront that the plans align with the task and its context, project rules, our own and industry best practices, and relevant standards. We’re applying a similar loop after implementation: AI performs the initial code review and sends the code back for revision if needed.

So, the next stage in the system’s development is self-review across different stages of the SDLC. The goal is to improve the quality of the output and reduce the amount of rework developers need to do. This functionality is now in the final stages of implementation; the next step is to test it and evaluate the results.

Next steps in Drupal AI integration

In the near term, we plan to expand the use of AI to other stages of the development process.

We’re already working on using AI in design and have developed a tool that automatically generates technical documentation based on a developer’s explanation.

Another area we’re focusing on is QA. We’re already working with AI skills for writing Cypress end-to-end automated tests and plan to expand this further by using AI to perform requirements testability analysis and create test cases.

Overall, our goal is to gradually bring AI into as many stages of the SDLC as possible.

The ideal development workflow of the future

The ideal process starts with a client request, even if it’s not clearly defined. AI analyzes the request and comes up with clarifying questions, which the developer reviews before adding their own ones and sending the final list to the client.

Next, AI helps flesh out the requirements and checks whether they’re feasible and testable. Subject-matter experts still review and validate the results, because the final responsibility remains with the human. Over time, AI could also be used to estimate tasks by training it on our project history and actual effort data.

At the design stage, the developer defines the high-level architecture, while AI works out the details and sends them for review. AI then writes the code and performs an initial check, after which the developer conducts the code review. Automated tests provide an early indication of whether the task is ready to move toward release.

Client review still remains part of the process, as do the preparation of technical and user documentation and mandatory human review of that documentation. At the same time, we need to keep in mind that in the future, documentation and interfaces will be used not only by people, but also by AI agents.

Across the Dev, Stage, and Production environments, we also expect to see more automation, with AI helping prepare deployment scripts, performing rollouts, checking pipeline logs for errors, and taking corrective actions. But initiatives, final decisions, architecture, and long-term system design — taking into account the client’s needs today, in the near future, and several years down the road — will remain the responsibility of people.