09 | 2025 Antti Rintala, Data Architect, Partner, Kipinä
It was a sunny Thursday in September when the leaders of Finnish ICT development quietly gathered to discuss an exciting topic: What can agentic artificial intelligence offer at its best for both software development and business growth?
Held for the very first time, Kipinä's 'Artificial Septelligence' event was anything but high-level AI discourse, focusing instead on hands-on experiments. Guided by Agentic Pasi Vuorio, participants explored how properly utilized AI agents transform everyday coding practices.
As software development undergoes a rapid transformation, one of the most significant paradigm shifts of our time is taking place within agent-based coding. As code-generating AI agents take over a portion of programming tasks, a critical question arises: how do we ensure high quality and a manageable outcome? The answer lies not in the latest 'quick fixes,' but in a return to fundamentals: documentation, test-driven development, and the systematic enhancement of quality.
We summarized the insights and new opportunities generated through the practical exercises at the Artificial Septelligence event, focusing on equipping language models with tools, workflow-oriented thinking, and systematic quality guidance.
Document Driven Development: Back to Basics
In software development, documentation has often been viewed as a necessary evil. It typically lags behind the code or becomes buried in the depths of project management tools. Document Driven Development flips this paradigm on its head: documentation is not a byproduct, but the starting point.
When AI agents generate code, they use documentation as their guiding light. These descriptions of system requirements, processes, and use cases are vital for agents to structure their work effectively. Good documentation also serves as the interface through which humans and agents understand one another.
In this sense, document-driven development is not a new fad, but a reminder that clear design before coding has always been the foundation of functional software engineering. Now, it takes on a new meaning: documentation no longer serves just humans, but artificial intelligence as well.
TDD and BDD: The 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 agentic coding, these practices take on an even more central role.
When tests are written first, they act not only as a quality assurance tool but also as instructions for the agent: this is what the code should look like.
Both approaches provide the AI with a concrete framework within which to operate. For example, an agent might generate code that passes tests yet fails to meet actual business requirements. Through BDD, requirements are documented in an understandable format, ensuring the agent's output closely aligns with the actual need.
Tools
The biggest advantage of agentic 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 transforms an agent from a mere code generator into an active agent capable of interacting with its environment.
For example, it can:
Run tests and scripts: Rather than guessing, the agent can execute code, review the results, and use them for the next iteration.
Call APIs and systems: The agent can directly leverage databases, CI/CD pipelines, or analytics tools, much like a human would from the command line.
Delegate to specialized language models: If a problem requires specialized expertise (such as translation, mathematical reasoning, or security analysis), the agent can route the task to another model and integrate the results back into the whole.
Build learning loops: Tool calling enables iteration: generate → run → review → refactor. This mirrors the human programming process, but executes faster and more systematically.
In other words, an agent is not merely a conversational partner, but a programmable team member with access to tools. The richer and better-defined the toolset provided to the agent, the more versatile and higher-quality its performance will be.
Workflows and Agent Task Distribution
Once tools and operating principles are in place, the next step is designing the workflow – determining how the overall scope is broken down into manageable parts. A defined requirement or specification can be divided into smaller development tasks, each handled individually.
This is where the agent swarm comes into play – a collective of specialized agents or sub-agents working in parallel:
the frontend agent focuses on the user interface
the backend agent builds server-side logic
the testing agent ensures quality by running tests and analyzing results
the documentation agent ensures that a clear record of the system remains for humans
The workflow acts as the glue combining these specialized functions into a cohesive whole. It ensures that the agents' work is not random, but progresses methodically toward a completed solution – much like organizing a software project around teams and roles.
Patterns and Antipatterns: Pairs for Enhancing Quality
An LLM agent does not "understand quality" the same way a human does, but it can guide the code it produces based on provided examples and boundaries. Therefore, simply stating "let's do it this way" is not always sufficient. A more effective approach is to provide both the pattern (what to aim for) and the antipattern (what to avoid).
Examples of pairing:
Pattern: Write tests before code (TDD).
Antipattern: Do not generate code without tests being defined.
Pattern: Refactor code into small, concise methods.
Antipattern: Avoid long, complex functions that are difficult to test.
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 accompanies the code and tests.
Antipattern: Do not leave documentation disconnected or allow it to become outdated in a separate file.
Why do pairs work?
For a human developer, it is often self-evident that a "good approach" also means avoiding certain practices. However, this is not always the case for an LLM agent. It may easily generate both tested and untested code if it has not been explicitly instructed on what to avoid.
When pattern/antipattern pairs are provided as instructions, the agent receives both a positive model and a negative boundary: do this, but do not do that. This makes the guidance more concrete and improves the quality of the output.
What insights were gained from the Artificial Septelligence event?
Agent-based coding offers immense possibilities – ranging from accelerating digital development to leveraging data and AI solutions and scalable software architectures.
However, it does not eliminate the fundamental requirements of software development: clear documentation, testable code, and quality management. When these elements are taken seriously, AI serves as an efficient partner – and at its best, transforms software development processes to be more sustainable and business-driving.
Therefore, AI agents do not change the fundamental laws of software development; they simply make them more critical than ever.
If you find this topic interesting, check out our other Insights articles, such as: