AI for software development

An agent proposes the code. A person signs it.

We bring coding agents into your team's development process, on the models and the infrastructure you choose, with the costs estimated before the investment.

Or write to us: info@ggtechnologies.sm

1997
the first project
18
years in manufacturing
900
workers in the study
The starting point

Writing is the fast part. The rest is the work.

An agent writes in minutes what used to take a day, and the bottleneck moves further down the line: review, automated tests, integration, and the time it takes to work out whether that code really does what it has to do.

So the work starts from the process rather than the tool: where the code lives, how it is tested, who approves a change and which parts stay out of the agent's reach. The agent comes into rules that are already written, and whoever integrates the code answers for what goes live.

The manual

Claude: la guida completa, a free public manual by Gian Angelo Geminiani on the AI assistant we use, updated alongside the product. It is in Italian.

The apps

The applications in the catalogue are published under the Apache-2.0 licence, tests included: read them and try them.

The course

Software development with Claude Code: four hours, over two sessions, for people who write code every day.

Development

Software designed and developed entirely in Europe.

What we set up

Four steps that bring an agent into a development process.

The four-hour course on Claude Code is in the training catalogue; if the code cannot leave, the choice is on-premise AI.

Model and infrastructure

Commercial models, open models on your own machines, or a mix of the two: the choice follows from where the code is allowed to be.

  • Confidential code stays on your systems
  • Models compared on the same task
  • The model supplier can be changed

Costs, estimated first

Consumption is measured on real tasks and projected onto the team's workload, before the investment.

  • A trial on tasks taken from your own archive
  • Cost per change and per review
  • Spending caps and alerts, where the supplier offers them

The rules of the repository

Instructions written next to the code: style, structure, tests to pass and parts the agent leaves alone.

  • A rules file that lives with the code
  • Automated tests before every integration
  • Sensitive areas stay out of reach

The people who will use it

Training is part of going live: developers learn to read, correct and turn down what the agent proposes.

  • Four hours on Claude Code, over two sessions
  • Review of the generated code
  • The course
How we work

The rules of your repository first, then the agent.

01

Look at the process

How the team works today: branches, reviews, tests, releases. The agent goes in here, not beside it.

02

Decide where it runs

Model and infrastructure, following where the code is allowed to be and what you want to spend.

03

Write the rules

Instructions in the repository, automated tests and limits on what the agent may change.

04

Measure

Time per change, defects caught in review and cost per task, set against the starting point.

FAQ

Frequently asked questions

Does my company's code end up in a third-party model?

Only if you decide it does. With models running on your own machines the code stays there; with commercial models you pick the plan, and the place of processing and the confidentiality terms are fixed in the contract before anything starts.

What does it cost in practice?

It is measured before the decision: real tasks are taken from your own archive, run with the agent, and the consumption is counted. Out of that comes the monthly cost per developer, and the decision is made with a number in hand.

Do I have to change language or tools?

No. The agent works on the repository you have, with the language and the tools you use. The rules we write live inside that repository, so they stay even on the day you change model or supplier.

Who answers for code an agent wrote?

Whoever integrates it and signs it. That is why the process has a person's review and automated tests before every integration: the agent proposes, the person approves.

Does it work on an old program as well?

Yes, and it is one of the uses that pays off most: reading code nobody has looked at for years, explaining it and proposing small, checkable changes. The limit is not the age of the code but how many automated tests it has: where they are missing, writing them is the first job.

Would you like to try an agent on your code?

Tell us how the team works today and where the time goes. We start from a real task, not from a demonstration.