Jira gebruiken voor agentgestuurde engineering

Agentgestuurde engineering draait op Jira. Naarmate engineering verschuift van het schrijven van code naar het aansturen van AI-agents, verschuift ook het werk dat ertoe doet. Developers besteden nu al maar ongeveer 16% van hun tijd aan het schrijven van code, en naarmate agents meer van het bouwen doen, zit het zware werk in alles eromheen: agents context geven, ze orkestreren, de uitvoer beoordelen en ze aansturen.

Dat is het werk dat Jira altijd heeft beheerd, nu uitgebreid naar agents. Jira en de Teamwork Graph zijn hiervoor de system of record, de vereiste laag die AI-activiteit omzet in echte productiviteitswinst naarmate teams opschalen.

In deze handleiding lees je hoe Jira agentgestuurde engineering ondersteunt, hoe het naast je andere tools past en hoe je aan de slag gaat. Kort gezegd biedt Jira drie dingen die een agent voor coderen alleen niet kan bieden:

• Zorgt dat agents zich in de juiste context bevinden, zodat ze nauwkeurig handelen

• Delegeert routinematig werk aan geautomatiseerde flows die rekening houden met machtigingen

• Houdt een verantwoordingsrecord binnen de Teamwork Graph bij

Wat is agentgestuurde engineering?

Agentgestuurde engineering is de praktijk van software bouwen door AI-agents aan te sturen die meerstapswerk plannen en uitvoeren, terwijl jij het doel bepaalt en het resultaat beoordeelt, in plaats van zelf elke regel code te schrijven.

Dit verandert waar je inspanning naartoe gaat: van code schrijven naar het systeem ontwerpen waarin agents werken. Je geeft aan wat je wilt builden, geeft agents context, stuurt ze bij terwijl ze werk doen en beslist of de uitvoer aan de norm voldoet. Waar AI-autocomplete de volgende regel voorstelt, kan één agent een beschreven resultaat omzetten in een pull request. Agentgestuurde engineering is de laag erboven: veel agents op grote schaal orkestreren, het werk coördineren en bepalen wat wordt uitgebracht.

Dat maakt agentgestuurde engineering een discipline van coördinatie en beoordelingsvermogen, en niet alleen van coderen. Zodra agents coderen of taken uitvoeren, moeten de toegang, acties en uitvoer binnen de controles blijven die je team al vertrouwt. De vragen die het oproept, gaan eerder over werkbeheer dan over coderen, en daarom leunt het op een registratiesysteem zoals Jira.

Is Jira gebouwd voor agentgestuurde engineering

Jira is gebouwd voor AI-native softwareontwikkeling, de praktijk van het plannen, orkestreren en opschalen van werk over AI-agents heen. Wanneer mensen vragen of Jira 'agentgestuurde engineering' ondersteunt, is de echte vraag of het de laag kan zijn waarin het werk van agents is verankerd in context en waarin dat werk wordt gecoördineerd, beoordeeld en beheerd. Dat is precies wat Jira doet, en een coderingsagent op zichzelf niet.

Een coderingsagent schrijft de wijziging, maar kan niet beslissen wat er moet worden gebouwd, beoordelen of het resultaat aan jouw norm voldoet, of verklaren hoe het werk aansluit op al het else dat al in uitvoering is. Dat zijn beslissingen over werkbeheer en van teams: een coderingsagent op de machine van één persoon werkt alleen voor die persoon, terwijl een team van mensen en agents gedeelde coördinatie, zichtbaarheid en één centrale informatiebron nodig heeft. Jira beheert die laag: het bevat het plan, stuurt het werk naar de juiste agent, zorgt dat iemand controle houdt over wat wordt geleverd en legt vast wat er is gebeurd als blijvende context die toekomstig werk informeert. Dit gebeurt terwijl werk door Jira gaat, niet als extra stappen die de developer moet nemen.

Wat voegt Jira toe dat een agent voor coderen alleen niet biedt?

Geef een coderingagent een echte specificatie en die kan nog steeds afdwalen. Het vergeet beslissingen, doet afgerond werk opnieuw en loopt tegen de limieten van het contextvenster aan. Het plan in een markdown-bestand bewaren is geen oplossing, en een betere agent ook niet. De oplossing is een systeem dat de specificatie en status buiten het geheugen van de agent houdt. Dit werkt door in een team. Daarom is agentgestuurde engineering eigenlijk een keuze voor een registratiesysteem, niet voor een coderingstool. De onderstaande mogelijkheden komen voort uit het feit dat Jira zelf dat systeem is.

Connectors verwerken je toolchain in de Teamwork Graph. MCP brengt dat organisatorische geheugen naar elke AI die je teams al gebruiken.

• Eén registratiesysteem voor menselijk werk en agentwerk. Terwijl een agent werkt, leest en schrijft deze in de Teamwork Graph en werkt elke beslissing en registratie rond de taak bij, zodat er geen context verloren gaat in een lokale sessie.

• Governance neemt de bestaande beheeropties van je organisatie over. Toegang voor agents volgt het rechtenmodel dat ondernemingen al vertrouwen, zodat die controles automatisch worden uitgebreid naar het werk van agents in plaats van dat er iets nieuws ontstaat dat je moet beheren.

• Elke agent, elk model, één omgeving. Wijs werk toe aan Claude, Cursor, Codex, GitHub Copilot of de native Jira-agent voor coderen en orkestreer ze vanuit één plek. Omdat agents binnen je bestaande workflows werken, verandert je proces niet wanneer agents dat wel doen. Eén enkele coderingsagent bindt je aan één leverancier, Jira is agent-agnostisch.

• Contextengineering vanuit de volledige stack, niet alleen vanuit het ticket. De Teamwork Graph voorziet agents van context uit werkitems, beslissingen en de volledige geschiedenis binnen Jira, Confluence, code en de tools waarin het werk daadwerkelijk wordt besproken, zoals Slack en Teams. Daardoor handelen ze op basis van daadwerkelijke intentie, en niet vanuit een blanco prompt. Zo vormt Jira de contextlaag rondom de agent.

• Het biedt één centrale bedieningslaag voor het werk van agents. Een coderingsagent werkt in een eigen sessie, losgekoppeld van het plan en het overige werk van het team. Jira voegt die laag toe om te bepalen welke taken agents oppakken, hen van de juiste context te voorzien en elke programmeersessie te koppelen aan het werk dat ermee wordt geleverd, zonder extra stappen toe te voegen aan de dagelijkse werkzaamheden van de ontwikkelaar. Waar het registratiesysteem vastlegt wat er is gebeurd, zorgt de bedieningslaag ervoor dat het werk van agents op de achtergrond wordt aangestuurd en met elkaar verbonden.

De rol van Jira binnen de AI-native levenscyclus van softwareontwikkeling

Jira ondersteunt werk van agents in vier fasen: plannen, orkestreren, beoordelen en (op)schalen. Je plant het werk in werkitems die gebruiksklaar zijn voor agents, orkestreert agents om het werk uit te voeren, beoordeelt en test wat ze produceren en schaalt deze patronen binnen de organisatie op met het juiste toezicht en de juiste rechten om alles veilig te houden. Dit is wat Jira bij elke stap doet.

Plannen: hoe maak je werk klaar voor agents?

Zet plannen en documentatie met één klik om in voorgestelde werkitems. Controleer en pas ze vervolgens zo nodig aan voordat je ze accepteert.

Plannen is waar je intentie omzet in werk dat gebruiksklaar is voor een agent: een echte specificatie met duidelijke vereisten en acceptatiecriteria, plus de context die een agent nodig heeft voordat die begint.

• Leg het werk vast op de plek waar het begint. Aanvragen komen overal vandaan: een Slack-thread, een Confluence-pagina, een Loom-opname, een vergadering. Vermeld @Jira of gebruik Rovo om ze direct om te zetten in werkitems. Intake voorkomt niet alleen dubbel typwerk: intake zet zelfs een vage aanvraag die in een gesprek is ontstaan om in een werkitem, met context uit de Teamwork Graph over hoe deze past binnen het werk van het team.

• Geef de agent een duidelijke specificatie, niet alleen een prompt. Bij specificatiegestuurde ontwikkeling vormt de specificatie het uitgangspunt: de agent werkt op basis van de specificatie aan het werkitem, in plaats van op basis van een eenmalige prompt die na de sessie verloren gaat. Die specificatie werkt samen met de codebase, teamstandaarden en projectgeschiedenis, zodat de agent de context heeft die nodig is om code op te stellen die aansluit bij de standaarden van je team. Jira Planner stelt een specificatie op met behulp van de Teamwork Graph, je codebase en de geschiedenis in Confluence. Vervolgens verfijn je deze en voeg je acceptatiecriteria toe. Zo wordt de specificatie de basis waarop de agent bouwt én waaraan het resultaat wordt getoetst.

• Geef agents context die steeds uitgebreider wordt. Context is de bepalende factor voor de kwaliteit van agents. Jira gebruikt de Teamwork Graph om agents te voorzien van de doelen, beslissingen en geschiedenis uit al je tools, niet alleen uit het ticket. Het werkt met elke MCP-agent en die context wordt steeds uitgebreider: hoe meer werk via het systeem verloopt, hoe meer informatie agents kunnen benutten en hoe beter de resultaten worden.

Orkestreren: hoe wijs je werk toe aan agents en stuur je dit aan?

Wijs werk toe aan agents, waaronder de native Jira-agent voor coderen, vanaf één plek.

Wijs werk toe aan de agent die er het best voor geschikt is en stuur en beheer vervolgens wat die agents doen, allemaal vanuit de plek waar je team het werk al bijhoudt.

• Wijs werk vanaf één plek toe aan elke agent. Wijs een werkitem toe aan Claude, Cursor, Codex, GitHub Copilot of de native Jira-agent voor coderen. Bekijk vervolgens de acties die de agent heeft uitgevoerd en de beslissingen die deze heeft genomen in web-, IDE- en terminalsessies. Zo kun je afwijkingen vroegtijdig signaleren en bijsturen zonder de flow te onderbreken.

• Ontmoet agents waar je al werkt. Orkestreer via de interfaces die je team al gebruikt: vermeld @Jira in Slack om een werkitem aan te maken en een oplossingscyclus te starten, verbind Cursor, Claude Desktop of een andere MCP-client met de context van Jira, of geef agents toegang tot de CLI/terminal om van context naar actie te gaan.

• Automatiseer routinematig werk. Activeer een agent vanuit een automatiseringsregel of een workflowtransitie (of voeg een agent toe aan een bordkolom), zodat deze automatisch werk oppakt wanneer de status verandert en de resultaten weer via dezelfde workflow worden teruggestuurd. Routinematig, terugkerend werk is de beste plek om te beginnen.

• Activiteit van agents blijft zichtbaar, gekoppeld aan het werk. Terwijl een agent werkt, blijft de activiteit en pull request die de agent opent gekoppeld aan het werkitem. Zo blijft de voortgang zichtbaar op de plek waar het werk zich bevindt, in plaats van verborgen te zijn in een afzonderlijke tool. Je ziet op één plek welk werk elke agent heeft opgepakt, wat de agent heeft geproduceerd en wat nog wacht op beoordeling.

Beoordelen: hoe valideer je de output van een agent?

De beoordeling van de uitvoer van agents moet een stap met menselijke tussenkomst omvatten.

De output van een agent kan er afgewerkt uitzien en toch onjuist zijn. Daarom mag deze pas worden geleverd nadat iemand de output heeft beoordeeld, getest en goedgekeurd.

• Testen en valideren. De output van een agent moet nog steeds de gebruikelijke controles doorlopen. Die controles worden uitgevoerd in je CI-pipeline en de status ervan wordt weergegeven in het werkitem. Zo kan een beoordelingsstap de overgang naar gereed tegenhouden totdat het werk is geverifieerd. Een deel hiervan kun je automatiseren: een agent voert controles uit op de eigen output en blijft herhalen totdat die slagen, voordat het werk bij een persoon terechtkomt.

• Beoordeling met menselijke tussenkomst, ingebouwd in je workflow. Maak een menselijke beoordeling verplicht: de output wordt weergegeven in het werkitem en kan pas naar gereed overgaan nadat iemand deze heeft goedgekeurd. De pull request en bijbehorende beoordelingsstatus worden weergegeven in het ontwikkelingspaneel van het werkitem, zodat de beoordeling plaatsvindt op de plek waar het werkitem wordt bijgehouden.

• Voeg samen en registreer wat is geleverd. Zodra de beoordeling is afgerond, wordt de wijziging samengevoegd en gaat het werkitem naar gereed. Samenvoegen en implementeren gebeurt in je gekoppelde tools; Jira houdt hiervan de registratie bij.

(Op)schalen: hoe zet je agents in de loop der tijd veilig in binnen verschillende teams?

Eén systeem van werk leidt tot meer succes bij het opschalen binnen de hele organisatie.

Het opschalen van werk van agents is een organisatiebrede verandering. De uitdaging ligt minder in het feit dat individuele ontwikkelaars meer agents inzetten en meer in het behouden van consistente kwaliteit, vertrouwen en zichtbaarheid naarmate het werk van agents zich over verschillende teams verspreidt.

• Delegeer routinetaken. Agents voeren terugkerend, duidelijk afgebakend werk op de achtergrond uit, pull requests verschijnen zodra ze klaar zijn en jij houdt de regie dankzij gedeelde rechten en beveiligingsstandaarden.

• Itereer. Agentgestuurde engineering is een cyclus, geen lijn: resultaten worden teruggekoppeld in de volgende specificatie en het werk doorloopt de cyclus opnieuw. Jira is de plek waar deze feedback wordt vastgelegd, zodat toekomstig werk verder kan worden verfijnd.

• Houd toezicht en controleer. Gebruikslimieten zijn ingebouwd in de workflow en zijn niet alleen vastgelegd in een beleidsdocument. Elke actie laat een controleerbaar spoor achter in het werkitem, beschermd door de eigen rechten van Jira.

• Meet de impact. Volg hoe AI de manier verandert waarop je team werk levert, met behulp van leveringsgegevens zoals cyclustijd en de doorvoer van pull requests. Zo meet je resultaten in plaats van alleen activiteit en kun je investeren waar dat de meeste impact heeft.

Hoe past Jira in de rest van je AI-stack?

Jira vervangt je coderingsagents, IDE of de modellen die je gebruikt niet. Het vormt de coördinatie- en registratielaag die over deze tools heen ligt, zodat werk zichtbaar en beheersbaar blijft, ongeacht welke tools het daadwerkelijke ontwikkelwerk uitvoeren. Wanneer je opschaalt is die laag niet optioneel, maar een noodzaak. Zonder een gedeeld registratiesysteem raakt het werk van agents gefragmenteerd over verschillende tools en kan de productiviteit niet volledig worden benut.

Aan de slag met agentgestuurde engineering in Jira

Bekijk de acties die je agents hebben uitgevoerd en de beslissingen die ze hebben genomen. Bekijk de volledige sessiegeschiedenis, merk afwijkingen vroeg op en corrigeer waar nodig.

Je hoeft niet meteen alles volledig uit te rollen om te beginnen. De snelste eerste winst behaal je door een coderingsagent te koppelen, deze één kleine taak toe te wijzen en de pull request die de agent opent te beoordelen, allemaal vanuit één werkitem.

1. Kies één routinematige, duidelijk afgebakende taak. Een instabiele test, een verhoging van een afhankelijkheid of een kleine bugoplossing is de veiligste plek om te beginnen.

2. Leg het vast als een werkitem. Zet een Confluence-pagina, een Slack-thread of een korte prompt om in een werkitem met een samenvatting en omschrijving.

3. Wijs het toe aan een agent. Koppel je Git-repository en wijs daarna het werkitem toe aan de Jira-programmeeragent vanuit het deelvenster Agenten.

4. Een pull request beoordelen. De agent opent een pull request die is gekoppeld aan het werkitem, zodat je die kunt beoordelen op dezelfde plek waar je hem hebt gepland.

5. Automatiseer het. Zoek na je eerste keer uitvoeren de taken die je steeds opnieuw doet en zet ze om in automatiseringsregels. Herhaald werk is dé plek om te beginnen met het hoogste rendement en het laagste risico.

Wil je een voorsprong? Configureer één keer, en de sjabloon voor agentische engineering stel een voor agenten voorbereide space op met workflows, statussen en agentstappen, zodat je kunt beginnen met een werkende cyclus in plaats van met een leeg project. Gebruik je al agentische workflows in een space die goed werkt? Betalende klanten kunnen dit opslaan als een aangepaste sjabloon, zodat je team nieuwe spaces kan aanmaken met dezelfde agenten en ingebouwde workflow.

Veelgestelde vragen over agentische engineering

Wat doet een engineer bij agentische engineering?

Een engineer die met agentische AI werkt, bepaalt de Doelen, context en richtlijnen die AI-agenten door werk in meerdere stappen sturen, en verzorgt vervolgens de beoordeling en goedkeuring van de resultaten. Een registratiesysteem zoals Jira houdt dat alles gecoördineerd blijft en dat verantwoordelijkheden duidelijk blijven.

Wat is het verschil tussen prompt-engineering en agentische engineering?

Bij prompt-engineering wordt één instructie opgesteld voor een goed modelantwoord; agentische engineering coördineert agenten die een hele taak plannen, uitvoeren en itereren. De werkeenheid is van de prompt tot het doel.

Wat voegt Jira toe dat een agent voor coderen alleen niet biedt?

Een programmeeragent schrijft code, maar Jira is de plek waar werk wordt gedefinieerd, geprioriteerd, georkestreerd, beoordeeld en beheerd als één centraal registratiesysteem. Het coördineert elke agent en houdt daarbij een auditspoor bij dat aan elk werkitem is gekoppeld.

Hoe krijgen AI-agenten context uit Jira?

Agenten halen context uit het werkitem zelf (vereisten en acceptatiecriteria) en uit de Teamwork Graph, die gerelateerd werk, documentatie en code met elkaar verbindt. Dat baseert de agent voordat die handelt niet alleen op de prompt.

Heb je nog steeds Jira nodig als AI de code schrijft?

Ja, en misschien zelfs nog meer: naarmate agenten sneller meer code produceren, verschuift de beperking naar het coördineren, beoordelen en beheren van dat werk. Jira is het controlecentrum dat agentuitvoer zichtbaar en controleerbaar houdt, en koppelt aan het werk waarvoor ze bedoeld was.