Pillar page

Mjukvaruutveckling med AI

En beprövad process för att automatisera mjukvaruutveckling med ett team av AI-agenter — från kravanalys, genom kodning och flerlagers testning (unit, integration, E2E, säkerhet, prestanda), hela vägen till produktionssättning med fullständig revisionsspårning.

Låt oss prata om ett pilotprojekt Våra tjänster

Vi driver ett team av specialiserade AI-agenter som deltar i varje steg av mjukvaruutvecklingens livscykel — från kravanalys, genom arkitekturdesign, kodning och flerlagers testning, hela vägen till kodgranskning, dokumentation och driftsättning med fullständig revisionsspårning.

Det är så vi bygger våra egna ESKOM AI-produkter — multi-agent-plattformen HybridCrew, granskningssystemet Compliance, mikrotjänsten KRS+CRBR och ett antal integrationer. Vi tillämpar samma process i kundprojekt: både vid utveckling av nya mikrotjänster och vid modernisering av legacy-system.

Den här artikeln beskriver hur det fungerar i praktiken: vilka uppgifter agenterna tar över, vilka som ligger kvar hos människan, vilka tester vi kör och varför processen är upprepbar.

Varför automatisera mjukvaruutveckling?

En klassisk mjukvaruutvecklingscykel (analys → kod → tester → granskning → driftsättning) tar typiskt 2-4 veckor för en medelstor funktion i ett moget team. Det mesta av den tiden går till repetitiva uppgifter: att skriva boilerplate, generera enhetstester, granska ändringar, uppdatera dokumentation, generera databasmigrationer. Allt är mottagligt för automatisering.

Målet med vår process är enkelt: två eller tre personer som arbetar med AI-agenter levererar samma värde som ett team på 8-10 personer — utan utbrändhet, med högre kvalitet (fler tester, bättre kodgranskning, fullständig dokumentation) och kortare time-to-market.

Det här handlar inte om att „AI kommer att ersätta utvecklare". Det handlar om att „utvecklare med AI kommer att ersätta utvecklare utan AI". Erfarna ingenjörer förblir oumbärliga — de designar arkitektur, fattar strategiska beslut, granskar komplexa ändringar. Agenterna tar över rutinarbetet.

Sex steg i processen

Pipeline från krav till produktion. Varje steg utförs av specialiserade AI-agenter, medan människor övervakar och godkänner nyckelbeslut.

Kravanalys och arkitektur

AI-agenter analyserar affärsdokumentation, kundsamtal (från transkriptioner) och befintlig kod. De föreslår mikrotjänstarkitektur, databasschema, endpoint-lista och behörighetsmodell. En människa (CTO/arkitekt) granskar och godkänner förslaget innan kodningen börjar.

Skriva kod (TDD)

Tester först, sedan implementation. En backend-agent skriver API:er i FastAPI/Express, en frontend-agent skriver React-komponenter. Varje ändring blir en separat pull request med ett tydligt commit-meddelande. Kodstandarder (Black, ESLint, Prettier) tillämpas automatiskt.

Flerlagers testning

Unit (pytest, Jest), integration (testcontainers med riktig PostgreSQL), E2E (Playwright), UI-snapshot, säkerhet (OWASP, gitleaks, bandit), prestanda (k6/locust), tillgänglighet (axe). Varje PR kör hela pipelinen — ett misslyckat test blockerar merge.

Kodgranskning av AI

En SecurityReviewer-agent skannar efter OWASP Top 10-problem, en QualityReviewer-agent kontrollerar läsbarhet och mönster, en ArchitectureReviewer-agent verifierar konsekvens med resten av systemet. Gränsfall eskaleras till människor.

Dokumentation och CHANGELOG

Varje logikändring = versionshöjning + post i CHANGELOG.md i Keep a Changelog-format. API-dokumentation (OpenAPI/Swagger) genereras automatiskt. CLAUDE.md uppdateras efter varje session med nya lärdomar.

Driftsättning med Change Request

Driftsättning sker alltid via Git (ALDRIG direkt scp). Först testmiljön med Playwright-verifiering, sedan produktion efter CR-godkännande. Driftsättningsskriptet innehåller en rollback-plan (<5 min) och hälsokontroller.

Vad vinner företaget?

Tusentals automatiserade tester

Varje produktionsprojekt har från flera tusen till tiotusentals tester — unit, integration, E2E, säkerhet, prestanda. Regressioner fångas i CI innan de når användare.

Fullständig revisionsspårning

Varje ändring i kod, databas eller konfiguration registreras: Git, revisionslogg i databasen, CHANGELOG, Change Request. Uppfyller kraven i ISO 27001, EU AI Act och GDPR.

Skalbarhet i teamet

Två eller tre personer med AI-agenter levererar samma värde som ett team på 8-10 personer. Utan utbrändhet, med högre kvalitet och kortare tidsramar.

Eskalering till starkare modeller

LLM-routing väljer rätt modell för varje uppgift: små ändringar — lokal Ollama (nollkostnad), komplex arkitektur — Claude Opus. Optimering av kostnad och kvalitet i ett.

Upprepbarhet och standarder

Varje projekt följer samma standarder: feature branch workflow, squash merge, Conventional Commits, CHANGELOG, EU AI Act, GDPR. En ny utvecklare förstår strukturen på första dagen.

Säkerhet som standard

Gitleaks på pre-commit + CI, hemligheter i HashiCorp Vault, privata repositories, Keycloak SSO, Tailscale VPN för interna tjänster. Inga kompromisser för hastighetens skull.

Flerlagers testning — grunden för kvalitet

Varje ändring i produktionskod går genom en komplett testpipeline. Inga undantag — även att fixa ett stavfel i en kommentar triggar CI, eftersom testpipelinen är inbyggd i en Git-hook, inte i ett politiskt utvecklarbeslut.

Enhetstester (unit): pytest, Jest, vitest. Täcker enskilda funktioner och klasser. >80% täckning för kritisk kod.
Integrationstester: testcontainers med riktiga instanser av PostgreSQL, Redis, Vault. Mockar endast för tredjeparts externa API:er.
End-to-end (E2E)-tester: Playwright i Firefox (standard), Chrome (valfritt). Simulerar fullständiga användarvägar: inloggning → åtgärd → verifiering.
UI-tester (snapshot, tillgänglighet): Playwright + axe-core. WCAG 2.0 AA som baslinje, Lighthouse 100/100/100/100 som mål.
Säkerhetstester: OWASP Top 10 (semgrep, bandit, eslint-plugin-security), gitleaks (skanning av hemligheter på pre-commit och CI), trivy (skanning av Docker-images).
Prestandatester: k6 eller locust för belastningstester, kontroll av p95/p99 svarstider under belastning.
Regressionstester: hela sviten körs före varje produktionsdriftsättning. Varje rapporterad bugg blir ett regressionstest.
Smoke-tester: en minimal uppsättning på 5-10 tester som körs efter driftsättning i produktionsmiljön (kom applikationen alls upp).
Acceptanstester: affärstester (Cucumber/Gherkin) som bekräftar att kravet har uppfyllts.

Ett misslyckat test = blockerad merge. Inga undantag. Om ett test är „flaky" (instabilt) analyserar en diagnostikagent grundorsaken och fixar testet eller koden, men tar aldrig bort testet utan ett mänskligt beslut.

Typiska användningsfall

De mönster vi tillämpar oftast. Varje har sin uppsättning agenter, verktyg och mallar. Time-to-value mätt i veckor, inte månader.

Modernisering av legacy-system

•Gammal monolitisk applikation (PHP/.NET, inga tester, svår att underhålla)
•Agenter delar upp monoliten i mikrotjänster (inkrementell process, utan driftstopp)
•Genererar karakteriseringstester (capture av nuvarande beteende) före refaktorering
•Datamigrering med fullständig revisionsspårning och rollback-plan

Ny enterprise-mikrotjänst

•Specifikation på ingång (Jira-ticket, PRD-dokument, mötestranskription)
•Arkitektur → kod → tester → granskning → driftsättning på 2-3 veckor
•Integration med befintlig SSO (Keycloak), revisionslogg, övervakning
•Full efterlevnad av EU AI Act och GDPR från första kodraden

Systemintegration

•Anslutning av ERP, CRM, KRS, Microsoft Graph, IBM, Cisco, externa partners
•Agenter skriver adaptrar, mappningar, retry/backoff, idempotens
•Integrationstester mot riktiga endpoints (sandbox-API:er)
•Övervakning (Prometheus + Grafana) och larm (Sentry) anslutna automatiskt

Multi-tenant-plattformar

•Multi-klient SaaS med fullständig dataisolering (per-tenant schema eller row-level security)
•Automatiserad kund-onboarding (Keycloak-provisionering, databas, roller)
•Fakturering baserad på SSO Billing SDK (token usage tracking, fail-open)
•Compliance: GDPR, ISO 27001, EU AI Act redo för granskning

Jämförelse: klassiskt team vs. process med AI

Aspekt	Klassiskt team (8-10 personer)	Team med AI-agenter (2-3 personer)
Time-to-market (genomsnittlig funktion)	2-4 veckor	3-7 dagar
Testtäckning	40-60% (om teamet har tid)	>80% som standard (tester genereras tillsammans med kod)
Kodgranskning	1 person, i genomsnitt 30-60 min	3 agenter (säkerhet, kvalitet, arkitektur) + människa vid komplexa ändringar
Dokumentation	Ofta ofullständig, „görs efteråt"	Genereras tillsammans med kod (OpenAPI, README, CHANGELOG)
Revisionsspårning	Git-historik	Git + revisionslogg i databasen + CHANGELOG + Change Request
Skalning	Linjär (fler personer = högre kommunikationskostnad)	Icke-linjär (fler agenter = samma antal personer som övervakar)
Compliance (EU AI Act, GDPR, ISO 27001)	Ofta extern granskning i efterhand	Inbyggd i processen från första kodraden

Vanliga frågor

Vad är automatiserad mjukvaruutveckling med AI?

Det är en process där specialiserade AI-agenter deltar i varje steg av mjukvaruutvecklingens livscykel: från kravanalys, genom arkitekturdesign, kodning, automatiserade tester (unit, integration, E2E, säkerhet, prestanda, regression), till kodgranskning och produktionsdriftsättning. Människor övervakar fortfarande processen och fattar nyckelbeslut, men rutinuppgifter (skriva kod, generera tester, refaktorering, dokumentation) utförs av AI-agenter med bibehållna kvalitetsstandarder.

Hur skiljer sig den här processen från klassisk programmering med Copilot?

Copilot är autokomplettering — det hjälper till att skriva enskilda kodrader. Mjukvaruutveckling med AI är full orkestrering: en agent planerar arkitekturen, en annan skriver koden, en tredje skriver testerna, en fjärde gör kodgranskning, en femte driftsätter. Var och en har sin specialisering, episodiskt minne (lär sig av tidigare projekt), verktyg och kontext. Resultatet: en betydligt större automatiseringsskala än med en enskild Copilot, med bibehållna enterprise-standarder (tester, säkerhet, revisionsspårning).

Vilka typer av tester kör den här processen?

Varje typ av test som mogna utvecklingsteam använder: enhetstester (unit), integrationstester, end-to-end (E2E), UI (Playwright), säkerhet (OWASP Top 10, gitleaks), prestanda (load), regression, smoke och acceptans. Tester skrivs före eller parallellt med koden (TDD), och varje ändring måste passera hela pipelinen.

Driftsätter AI kod till produktion på egen hand?

Nej — inte automatiskt. Produktionsdriftsättningar kräver en godkänd Change Request (CR) och ett mänskligt beslut. AI-agenter förbereder ändringsdokumentation, kör regressionstester, genererar driftsättningsskript med rollback-planer, men den slutliga produktionsutrullningen kräver operatörens godkännande. Denna regel är medveten — den minimerar risken för oväntade utfall och bevarar en fullständig revisionsspårning.

Fungerar den här processen för enterprise-projekt?

Ja. Vi använder den i våra egna produkter, inklusive multi-agent-plattformen HybridCrew, konsultplattformen med SSO, PostgreSQL-baserade mikrotjänster och integrationer med externa system (KRS, MS Graph, IBM, Keycloak). Varje projekt har sin egen CI/CD-pipeline, dev/test/prod-miljöer, övervakning och revisionslogg. Processen skalar från en enskild mikrotjänst till en plattform med flera containrar.

Hur lång tid tar det att rulla ut den här processen i vårt företag?

Det beror på kontexten. För ett litet team (1-3 utvecklare) tar integration med befintligt repository och CI/CD-pipeline typiskt 2-4 veckor: granskning, agentkonfiguration, anpassning till kodstandarder, utbildning. För större organisationer tar pilotprojekt (ett team, en mikrotjänst) 6-8 veckor, följt av gradvis expansion till ytterligare team.

Hur är det med säkerheten för källkoden?

Kundens repositories lämnar aldrig till externa tjänster utan uttryckligt samtycke. Som standard körs hela processen (AI-agenter, LLM-modeller, vektordatabas, revisionslogg) i kundens infrastruktur eller i ESKOM AI:s privata moln med full isolering. Hemligheter hanteras via HashiCorp Vault, koden skannas av gitleaks före varje commit, och alla repositories är privata som standard.

Kommer ni att ersätta vårt utvecklingsteam?

Nej. Erfarna utvecklare är oumbärliga — de designar arkitektur, fattar beslut, granskar komplexa ändringar, löser ovanliga problem. AI-agenter tar över repetitiva, automatiseringsvänliga uppgifter: skriva boilerplate, generera tester, dokumentation, refaktorering, kodgranskning på första nivån. Målet: två eller tre personer med AI levererar samma värde som ett team på 8-10 personer — utan utbrändhet, med högre kvalitet och fullständig revisionsspårning.

Hur mycket kostar mjukvaruutveckling med AI?

Prissättningen är alltid projektspecifik och beror på skala, faktureringsmodell (plattformsprenumeration vs. dedikerat projekt), nödvändiga integrationer och om agenterna körs på lokala LLM-modeller (Ollama på kundens GPU — lägre driftskostnad) eller i molnet (Anthropic, OpenAI — högre flexibilitet). I pilotprojekt strävar vi efter avkastning på investeringen inom det första kvartalet efter full lansering.

Vilka är de typiska signalerna på att ett företag är redo för den här processen?

De bästa resultaten kommer från team som redan har: ett versionskontrollerat repository (Git), definierade kodstandarder, en grundläggande CI/CD-pipeline, tydligt dokumenterade krav (Jira/Linear/egna) och en kodgranskningskultur. Om något av dessa saknas blockerar det inte utrullningen — vi börjar då med granskning och grundläggande arbete. De minst mogna organisationerna är de utan versionskontroll eller med produktionskod som ingen testar.

Redo för ett pilotprojekt?

Vi börjar med en granskning av den befintliga processen och ett pilotprojekt på en vald mikrotjänst. Första resultaten synliga inom 2-4 veckor. Inga långsiktiga kontrakt krävs.

Boka ett samtal Se våra produkter