Artificial Septelligence 2025 - unlocking the power of agent-based coding
09 | 2025 Antti Rintala, Data Architect, partner at Kipinä
It was a sunny Thursday in September when the leaders of Finnish ICT development quietly gathered to discuss an exciting topic: What can agent-based artificial intelligence offer at its best for both software development and business growth?
The first Kipinä Artificial Septelligence event was anything but a general discussion of AI; above all, it was a practical experiment. Led by Pasi Vuorio from Agentti, the participants discussed how AI agents, when used correctly, can change everyday coding.
With software development changing at a rapid pace, one of the biggest transformations currently taking place is in agent-based coding. When AI agents that generate code can handle part of the programming work, the question arises: how can we ensure high quality and a manageable end result? The answer is not to be found in the latest 'tricks of the trade', but in a return to the basics: documentation, test-driven development, and systematic quality improvement.
We summarized the insights and new opportunities that emerged from the practical exercises at the Artificial Septelligence event, when language models gain access to tools, workflow thinking, and systematic quality control.
Document Driven Development; back to basics
In software development, documentation has often been seen as a necessary evil. It often lags behind the code or gets buried in project management tools. Document Driven Development turns this assumption on its head: documentation is not a by-product, but a starting point.
When AI agents generate code, they are guided by documentation. These descriptions of system requirements, processes, and use cases are essential for agents to structure their work. Good documentation also serves as an interface through which humans and agents can understand each other.
In this sense, document-driven development is not a new fad, but a reminder that clear planning before coding has always been the basis of successful software development. Now it just has a new meaning: documentation no longer serves only humans, but also artificial intelligence.
TDD and BDD: familiar cornerstones of test-driven development
Test-driven development (TDD) and behavior-driven development (BDD) have always been about ensuring requirements and quality in advance through testing. In agent-based coding, these practices take on an even more central role.
When tests are written first, they serve not only as a quality assurance tool but also as guidance for the agent: this is what the code should look like.
However, both provide AI with a concrete framework within which to operate. For example, an agent can generate code that passes tests but does not necessarily meet the actual needs of the business. With BDD, requirements are recorded in an understandable format, which means that the agent's output is closer to the actual need.
Tools
The biggest advantage of agent-based development is not just that the language model can generate text or code. Its real power comes from the fact that the agent can use tools—that is, call programmatic interfaces, run scripts, and even control other specialized models. This is called tool calling.
Tool calling makes the agent more than just a code generator: it becomes an actor that can influence its environment.
For example, it can:
Run tests and scripts: The agent doesn't just guess, it can execute code, see the results, and use them for the next iteration.
Call interfaces and systems: The agent can utilize databases, CI/CD pipelines, or analytics tools directly, just as a human would do on the command line.
Delegate to specialized language models: If a problem requires specific expertise (e.g., translation, mathematical reasoning, or security analysis), the agent can direct the task to another model and combine the results back into the whole.
Building learning loops: Tool calling enables iteration: generate → run → check → refactor. This resembles the human programming process, but happens faster and more systematically.
In other words, an agent is not just a conversation partner, but a programmable team member with access to tools. The richer and better defined the toolkit given to the agent, the more versatile and higher quality its performance will be.
Workflow and division of labor among agents
Once the tools and methods are in place, the next step is to consider the workflow—that is, how to break down the whole into manageable parts. A defined requirement or specification can be divided into smaller development tasks, each of which is handled separately.
This is where agent swarm comes in – a group of specialized agents or sub-agents that work in parallel:
frontend agent focuses on the user interface
The backend agent builds the server-side logic.
The testing agent ensures quality by running tests and analyzing the results.
The documentation agent ensures that the whole process leaves a mark on people as well.
Workflow is the glue that binds these specialized functions together into a single entity. It ensures that agents' work is not random, but progresses step by step toward a finished solution—in the same way that a software project is organized into teams and roles.
Pattern/antipattern; pairs as quality enhancers
An LLM agent does not "understand quality" in the same way as a human, but it can control the code it produces according to given examples and limits. Therefore, simply saying "do it this way" is not always enough. It is more effective to provide both a pattern (what to aim for) and an antipattern (what to avoid).
Examples of pair thinking:
Pattern: Write tests before code (TDD).
Antipattern: Do not generate code without defining tests.
Pattern: Refactor the code into small, clear methods.
Antipattern: Avoid long, complex functions that cannot be easily tested.
Pattern: Use clear, descriptive names for variables and methods.
Antipattern: Do not use cryptic abbreviations or generic names (e.g., tmp, data1).
Pattern: Write documentation that follows the code and tests.
Antipattern: Do not leave documentation isolated or outdated in a separate file.
Why do couples work?
For human developers, it is often self-evident that "good practice" also means not doing certain things. However, this is not always the case for LLM agents. For example, it may well produce both tests and untested code if it has not been clearly told what to avoid.
When pattern/antipattern pairs are set as guidelines, the agent receives both a positive model and a negative limit: do this, but don't do that. This makes the guidance more concrete and improves the quality of the output.
What insights did you gain from the Articial Septelligence event?
Agent-based coding offers tremendous opportunities – always accelerating digital development to the utilization of data and AI solutions to scalable software architectures.
However, this does not eliminate the basic requirements of software development: clear documentation, testable code, and quality control. When these elements are taken seriously, AI acts as an effective partner—and at its best, it makes software development processes more sustainable and business growth more sustainable.
Artificial intelligence agents do not change the basic laws of software development; they simply make them even more important.
If you are interested in this topic, check out our other Insights articles, for example: