The first part of this series focused on what agentic coding is now capable of and where human oversight is still needed. This time, we will take a look at our own approach.
For us, this journey began quite unspectacularly. GitHub Copilot completed a line of code. That was useful and, to be honest, a little astonishing. The tool seemed to understand what the developer was getting at. At that time, we were still a long way from having an agent that could independently handle a larger task within a project.
Today, we use Claude Code and OpenAI Codex every day. GitHub Copilot continues to help with small additions. We also have a computer with a powerful graphics card on which we run Qwen locally. In between, there have been many experiments, a few dead ends, and a significant shift in the way we develop software.
Getting Started with GitHub Copilot
It all started with autocomplete features. Copilot would fill in individual lines, and later even an entire paragraph. Compared to today’s coding agents, that sounds modest. In day-to-day work, however, the effect was immediately noticeable. Repetitive code was written more quickly, minor interruptions became less frequent, and it was easier to stay on track with one’s train of thought.
With the chat, our collaboration became more versatile. We were able to have existing code explained to us, create short functions, or have a class designed for us. What started as simple code completion gradually evolved into a dialogue.
Then came the first agent-based features. We were sold on the idea, but the wait times were not convincing yet. Especially in larger projects, it often took so long to get a response or a change that the benefits in our day-to-day work remained minimal.
With Codex, Things Suddenly Got Serious
OpenAI Codex significantly changed our perception. Its range of features was already surprisingly close to today’s agent-based work. To us, it felt revolutionary at the time.
Suddenly, it was about more than just individual suggestions. A tool could capture a coherent task, navigate the project, and prepare changes. The question “How do I write this line?” came up less and less often. Much more frequently, the question was: “How do I describe the task so that the agent can process it effectively?”
With that came greater responsibility. A developer can modify many files in a short amount of time. Just as quickly, they can misinterpret a requirement or choose a solution that works technically but does not fit well with the rest of the project. Clear task descriptions, a clear context, and thorough reviews therefore became even more important.
Try Lots of Things, But Make Sure To Weed Them Out
We tested several tools during our journey. At first, we used OpenCode extensively. The working environment surrounding the model was powerful and, in our view, could hold its own against well-known coding assistants. Another interesting feature was the ability to integrate self-hosted models.
Over time, however, we did not see any clear advantage over the other tools. At the same time, there were still too many uncertainties regarding data sharing. As a result, OpenCode became less important in our day-to-day work.
We do not have any practical experience with Pi yet, hence we are holding off on making a judgment at this point.
The tests have resulted in a fairly pragmatic toolkit. Today, we primarily use GitHub Copilot for code completion directly in the editor. For larger tasks, we usually turn to Claude Code or OpenAI Codex. We use both of them extensively. Which tool is used for a given task depends on the specific work at hand, the developer’s preferences, and the currently available usage quota.
We have since given up on finding a single winner. What matters is which tool reliably helps in each specific situation.
Why We Have a Dedicated Computer for Language Models
As we have started using cloud services more extensively, the question of how much control we can retain over models and data flows has become increasingly important to us. That is why we purchased a computer with a high-performance graphics card. Qwen is currently running on it as a local language model.
We use this computer to implement and test Agentic Coding in-house. With fully local execution, queries and code remain on our own infrastructure. At the same time, we gain practical experience with models, hardware, storage requirements, and integration into existing development workflows.
For client projects, we also clarify in advance which tools may be used and which data can be processed. The use of a coding agent must be appropriate for the project and the agreed-upon terms and conditions.
Our local models are currently running more slowly and do not yet consistently match the quality of the leading cloud-based models when performing demanding tasks. That is precisely why practical operation is so valuable. We can see for ourselves what already works, where there are still issues, and how new model versions perform in the day-to-day reality of development.
For us, the computer is both a tool and a learning environment. It gives us an additional opportunity to use Agentic Coding and build on our experience using our own infrastructure.
Our Learnings
A lot has changed since the first proposal in Copilot to the locally operated model. Today, spectacular demos impress us less than they used to. What matters more are questions that can only be answered in a real-world project: Does the agent understand the codebase? Are its changes traceable? Does the solution fit the existing architecture? And do we know where our data is being processed?
Agentic Coding has now become an integral part of Sensetence. It speeds up many steps, handles routine tasks, and helps turn ideas into working software more quickly. Architecture, program logic, and the big picture remain the responsibility of our developers. We continue to bear responsibility for the final result.
In the third part of this series, we will shift our perspective, explore what agentic coding means for companies in concrete terms and how it can impact development time, costs, and the implementation of new ideas.
Are you working on agentic coding, an existing software project, or an idea that has seemed too time-consuming so far? Write to us. The best way to determine which tool can make a real difference is to discuss your specific project.
The question what this approach means for companies and their software projects still remains. Will development really be faster? Where can costs be reduced, and in which areas is special care still required? That is what we will explore in the third part of our series.