Voor software die al draait bij een ander bureau
Bestaande software?
Zet er een agent op
Je applicatie draait, maar een wijziging van een uur kost bij je huidige bureau twee weken wachten. Wij zetten de Code Agent op de repository die je al hebt. Daarna vraag je elke wijziging aan in de chat, je ziet hem in een preview en een architect beoordeelt hem voordat hij live gaat. Dezelfde controles en dezelfde drie poorten als in onze fabriek, op jouw code.
Wat je aanvraagt in de chat
Onderhoud en doorontwikkeling zijn allebei gewoon taken in dezelfde lijst
Bijwerken
Verouderde pakketten, een nieuwe versie van je framework, ontbrekende tests. Je vraagt het aan, de agent bouwt het en de tests draaien mee bij elke pull request.
Koppelen
Een koppeling met je boekhouding, je CRM of een leverancier. Elke koppeling is een taak met acceptatiecriteria, zodat data stroomt en niemand dubbel werk doet.
Versnellen
Trage schermen, zware query's, hoge hostingkosten. Je noemt het scherm, de agent meet en verbetert, en jij klikt in de preview of het merkbaar sneller is.
Beveiligen
Security-patches en dependency-updates gaan langs dezelfde controles als elke andere taak. Een architect kijkt mee voordat ze worden samengevoegd.
Auto's krijgen een APK, software eigenlijk ook
Net als een motor die regelmatig olie vraagt, heeft je platform updates, opgeruimde code en nieuwe features nodig om soepel te blijven lopen. Bij een bureau staat dat werk in een wachtrij. In de fabriek is het een taak die start op het moment dat je hem aanvraagt.
Wat dat je oplevert
Een wijziging start op het moment dat je hem aanvraagt, niet bij de volgende planning
Op elke wijziging draaien tests, code style en statische analyse mee
Een architect beoordeelt elke implementatie in de preview voordat hij live gaat
De code blijft in je eigen repository en je houdt het intellectueel eigendom
Van wachtrij bij je bureau
naar zelf aanvragen in de chat
Dezelfde zes stations als in onze fabriek, maar dan op de code die je al hebt. Wil je de fabriek zelf zien, lees dan hoe de fabriek werkt.
-
Je verzoek
Het begint in de chat, op je bestaande project. We koppelen eerst je repository en kijken wat er staat: welke code, welke pipeline, welke achterstand. Daarna beschrijf je wat je wilt veranderen en waaraan je het afmeet. Dat kan een nieuw scherm zijn, maar ook een bug of een pakket dat al twee jaar niet is bijgewerkt.
-
Het bouwplan
Voor bestaande software is het bouwplan kort, vaak een enkele taak met acceptatiecriteria. Bij een grotere wijziging worden het er meer, elke taak op zijn vaste plek. Je ziet de omvang voordat er iets start en geeft akkoord. Dat is de eerste poort.
-
Agents bouwen
Een planner schrijft de taakinstructie, een bouwer implementeert in jouw codebase, een reviewer becommentarieert en een fixer verwerkt dat tot tests, code style en statische analyse groen zijn. Er wordt een taak tegelijk gebouwd en elke taak is precies een pull request. Op je projectscherm zie je wat de agent nu doet.
-
Architect beoordeelt
Elke implementatie wordt in de preview beoordeeld voordat hij wordt ingediend. Een architect van ons kijkt naar architectuur, veiligheid en of het prettig werkt, en let in bestaande code extra op wat er onbedoeld mee verandert. Jij klikt in dezelfde preview mee. Dat is de tweede poort.
-
Samenvoegen en uitrollen
Zonder goedkeuring komt er geen samenvoeging. Dat is de derde poort. Samenvoegen en uitrollen doet altijd een mens, en dat mag jij zelf zijn, want de code staat in de repository die je al had. Aan de code komt vrijwel geen handwerk te pas, aan de beslissing wel.
-
Livegang
Je wijziging staat live in je eigen omgeving. De volgende vraag je aan in de chat en die gaat langs precies dezelfde zes stations. Achterstallig werk zet je gewoon als taken in dezelfde lijst. Je wacht niet op een planning bij een bureau, want een taak start op het moment dat je hem aanvraagt.
Wat kost software onderhoud en doorontwikkeling?
Geen offerte en geen schatting vooraf. Per wijziging zie je de omvang van het bouwplan voordat je akkoord geeft. Bouwen betaal je uit je AI-tegoed, en je verbruik en je resterende tegoed volg je doorlopend. De beoordeling door onze architecten zit op de drie poorten.
Een kritische blik op legacy
Waarom "weggooien en opnieuw beginnen" zelden slim is
Je herkent het vast: de bouwer van destijds is weg, documentatie is summier en de code voelt als spaghetti. Toch betekent dat niet automatisch opnieuw beginnen.
Beschadigde maar waardevolle fundamenten
Vaak zit er in legacy-code unieke proceslogica en zitten er koppelingen met interne systemen in. Die een-op-een herschrijven kost tijd en geld, en levert pas aan het eind iets op.
Risico's van een big-bang-rebuild
Lange periodes waarin er niets mag veranderen
Verlies aan domeinkennis
Onvoorziene regressies die pas laat naar boven komen
Stap voor stap moderniseren (denk aan het strangler-pattern en feature-toggles) geeft rust en continuïteit. In de fabriek is elke stap daarvan gewoon een taak in het bouwplan, met een pull request die je in de preview beoordeelt.
Praktische tips die je morgen kunt toepassen
Klein beginnen, groot effect
Werk je dependencies wekelijks bij, niet jaarlijks. Kleine updates zijn kleine taken.
Zet een readme op het hoogste niveau met setup-instructies in vijf stappen.
Voeg health-endpoints toe voor monitoring: /status geeft 200 OK.
Automatiseer database-migraties met versiebeheer.
Zet achterstallig werk gewoon als taken in dezelfde lijst, dan schuift het niet door.
Bonus: test-coverage
In de praktijk zie je vaak dat 60% coverage genoeg is voor vertrouwen. 100% klinkt mooi, maar vertraagt. Ontbrekende tests voor een kritisch stuk vraag je aan als taak; de agents schrijven ze en laten ze meedraaien bij elke volgende pull request.
Vooruitblik naar de toekomst
Van reactief naar voorspellend onderhoud
Machine learning klinkt als een buzzword, maar voorspellende monitoring ziet performance-degradatie aankomen op basis van afwijkingen in je logs. Je zou het bijna magisch noemen, tot je de data ziet.
Concrete scenario's
Geheugenlekken signaleren voordat de applicatie omvalt
Gebruikersflow-analyse om te bepalen welke feature je als eerste aanvraagt
Security-scans die CVE-feeds volgen en de patch als taak in je lijst zetten
Zulke tooling is vaak open source en kost vooral inregelen, niet zoveel licentiekosten. En inregelen is precies het soort taak dat je in de chat aanvraagt.
Veelgestelde vragen
Praktische antwoorden op de vragen die we het vaakst horen over software onderhoud en doorontwikkeling.
Waarom zou ik Spartner vertrouwen met code die jullie niet schreven?
Sinds 2004 bouwen en onderhouden we software voor startups en MKB, en bestaande projecten overnemen doen we al jaren. We koppelen eerst je repository en kijken wat er staat. Wat we vinden, leggen we open op tafel, en de agent gaat pas aan het werk als jij akkoord bent.
Hoe snel kunnen jullie aan de slag?
Zodra je repository gekoppeld is, vraag je je eerste wijziging aan in de chat. Een taak start op het moment dat je hem aanvraagt, niet bij de volgende planning. Bij een grote monoliet kijken we eerst langer naar wat er staat voordat de agent de eerste taak oppakt.
Wordt onderhoud niet duurder dan een rebuild?
Niet per se. Door per taak te werken spreid je je verbruik en voorkom je een lange periode waarin niets mag veranderen. Je ziet per wijziging de omvang van het bouwplan voordat je akkoord geeft, en het verbruik van je AI-tegoed volg je doorlopend. Een rebuild slokt in een klap budget en aandacht op.
Hoe borgen jullie security?
Security-patches en dependency-updates zijn taken als alle andere: tests, code style en statische analyse draaien mee, en een architect beoordeelt elke implementatie voordat hij wordt samengevoegd. Een kritiek lek meld je in de chat en pak je als eerstvolgende taak op.
Kan ik tussentijds nieuwe features blijven lanceren?
Ja. Achterstallig onderhoud en nieuwe features staan als taken in dezelfde lijst. Er wordt een taak tegelijk gebouwd, dus jij bepaalt de volgorde: eerst dat ene scherm en daarna de pakketupdates, of andersom.
Wat als mijn oude freelancer toch opeens terugkeert?
Geen probleem. De code staat de hele tijd in je eigen GitHub of Bitbucket, elke wijziging staat erin met een leesbare beschrijving en je houdt het intellectueel eigendom. Wie er ook aan verder werkt, alles staat op een plek.
Werken jullie in vaste planningsrondes?
Nee. Er is geen planning waar je wijziging op moet wachten. Je vraagt hem aan in de chat en de taak start op dat moment. Jij bepaalt het ritme: een taak per maand of tien per week.
Wat spreken we af over kwaliteit?
Elke taak heeft acceptatiecriteria die we samen in de chat vastleggen, en de agents controleren die zelf. Daarbovenop draaien tests, code style en statische analyse mee bij elke pull request, en beoordeelt een architect elke implementatie in de preview. Wil je een meetbaar doel, zoals een laadtijd voor een scherm, dan zet je dat in de acceptatiecriteria.
Moet ik migreren naar jullie platform?
Nee. De Code Agent werkt in de repository en de pipeline die je al hebt. Je hoeft niets over te zetten en je kunt er op elk moment mee stoppen, want de code is en blijft van jou.