Taken genereren en code implementeren

  • 10 minuten

Technische plannen bieden architectuurrichting, maar implementatie vereist concrete, bruikbare stappen. In deze les worden geavanceerde technieken voor het genereren en beheren van taken voor bedrijfsscenario's behandeld.

Grondbeginselen van taken beoordelen

Met de /speckit.tasks-opdracht van GitHub Spec Kit worden beslissingen op hoog niveau omgezet in specifieke work items in het bestand tasks.md. Elke taak vertegenwoordigt een afzonderlijke werkeenheid die onafhankelijk kan worden geïmplementeerd, getest en geverifieerd.

Belangrijke kenmerken van goed afgebakende taken:

  • Uitvoerbaar: geeft duidelijk aan wat er moet gebeuren.
  • Testbaar: verificatie van voltooiing is eenvoudig.
  • Onafhankelijk: kan worden voltooid zonder te wachten op niet-gerelateerd werk.
  • Tijdgebonden: kan binnen een redelijke periode (uren tot een dag) worden voltooid.

Op fasen gebaseerde organisatie

Complexe functies profiteren van het ordenen van taken in fasen. Bijvoorbeeld: Setup, Foundation, Core Functionality, UI/Integration, Security en Testing. Elke fase vertegenwoordigt een logische groepering die voortbouwt op een mijlpaal.

Voordelen van uitsplitsing van taken

Taakverdelingen dienen voor meerdere doeleinden, behalve alleen het organiseren van werk. Ze helpen de AI gerichte code te genereren voor specifieke doelstellingen in plaats van volledige functies in één bewerking te implementeren. Ze maken natuurlijke verificatiepunten waar u gedeeltelijke implementaties kunt testen voordat u doorgaat. Ze maken nauwkeurige voortgangstracering mogelijk door precies weer te geven wat er is voltooid en wat er overblijft. Ze faciliteren teamcoördinatie door afhankelijkheden expliciet te maken.

Voor de functie voor het uploaden van documenten beschrijft het plan de algemene architectuur- en technologiekeuzen. De takenlijst vertaalt architectuurbeslissingen in specifieke acties: maak een databasetabel, implementeer een API-eindpunt, bouw een React-onderdeel, voeg validatielogica toe, schrijftests. Elke taak is klein genoeg om binnen een redelijke periode te voltooien, terwijl deze groot genoeg is om zinvolle voortgang weer te geven.

Taakstructuur en organisatie onderzoeken

Een goed gestructureerde takenlijst organiseert logisch werk, reeksen afhankelijkheden op de juiste manier en biedt duidelijke richtlijnen voor implementatie.

Op fasen gebaseerde organisatie

Complexe functies profiteren van een gefaseerde organisatie. Elke fase vertegenwoordigt een logische groepering van gerelateerde taken die zijn opgebouwd naar een specifieke mijlpaal.

Voor de functie voor het uploaden van documenten kan een typische fasestructuur het volgende omvatten:

  • Fase 1: Basis en configuratie

    • Stel de Azure Blob Storage-verbindingconfiguratie in appsettings.json in.
    • Maak de DocumentMetadata-tabel in de SQL-database met het juiste schema.
    • Voeg het NuGet-pakket Azure.Storage.Blobs toe aan het back-endproject.
    • Maak de DocumentService-klasse waarin opslagbewerkingen worden ingekapseld.

  • Fase 2: Kernfunctionaliteit voor uploaden

    • Implementeer POST/api/documents/upload-eindpunt in DocumentsController.
    • Voeg bestandsvalidatielogica (grootte, type) toe aan DocumentService.
    • Implementeer de uploadmethode voor blob-opslag met foutafhandeling.
    • Sla documentmetagegevens op in de database na het uploaden.
    • Retourneer het uploadresultaat met document-id en URL naar client.

  • Fase 3: Front-end-implementatie

    • Maak het React-onderdeel DocumentUpload met bestandsinvoer.
    • Voeg de bestandsgrootte en typevalidatie toe in het onderdeel.
    • Voortgangsindicator voor uploaden implementeren.
    • Omgaan met succesvolle en foutreacties bij het uploaden.
    • De lijst met documenten vernieuwen na het uploaden.

  • Fase 4: Beveiliging en validatie

    • Voeg een verificatiecontrole voor Microsoft Entra-id's toe aan het uploadeindpunt.
    • Implementeer validatie van bestandstypen aan de serverzijde met behulp van magic numbers.
    • Limieten voor aanvraaggrootte toevoegen die DoS-aanvallen voorkomen.
    • Bestandsextensies valideren op basis van een lijst met toegestane bestanden.
    • Voeg auditlogboekregistratie toe voor uploadbewerkingen.

  • Fase 5: Testen en documentatie

    • Eenheidstests schrijven voor DocumentService-uploadmethoden.
    • Maak een integratietest voor de volledige uploadstroom.
    • Foutscenariotests toevoegen (ongeldig bestandstype, grootte overschreden).
    • Document-API-eindpunt in OpenAPI/Swagger.
    • Gebruikersdocumentatie bijwerken met uploadinstructies.

Deze gefaseerde benadering creëert natuurlijke mijlpalen. Na fase 2 hebt u een werkende maar minimale back-end. Na fase 3 kunnen gebruikers bestanden uploaden. Na fase 4 is het systeem veilig en productieklaar. Na fase 5 wordt alles getest en gedocumenteerd.

Taakgranulariteit en bereik

Elke taak moet op de juiste wijze worden afgestemd, specifiek genoeg om duidelijke richting te bieden, maar niet zo gedetailleerd dat het prescriptieve micromanagement wordt.

Goed gedefinieerde taken delen deze kenmerken:

  • Actie mogelijk: De taak geeft duidelijk aan wat er moet worden gedaan.
  • Testbaar: U kunt controleren wanneer de taak is voltooid.
  • Onafhankelijk indien mogelijk: De taak kan worden voltooid zonder te wachten op niet-gerelateerd werk.
  • Tijdgebonden: een ontwikkelaar kan de taak binnen een redelijke periode voltooien (meestal uren tot een dag, niet weken).

Voorbeeld van een goed gescope opdracht: "Implementeer de POST /api/documents/upload endpoint die multipart bestand uploads accepteert, valideert dat de bestandsgrootte onder de 50 MB is, slaat het bestand op in Azure Blob Storage en retourneert de blob-URL en document-ID."

Deze taak is specifiek voor het bouwen (een eindpunt), wat het accepteert (bestanden met meerdere onderdelen), welke validaties moeten worden toegepast (groottelimiet), waar bestanden moeten worden opgeslagen (Azure Blob Storage) en wat moet worden geretourneerd (URL en id). Een ontwikkelaar weet precies wat er moet worden geïmplementeerd.

Hier volgt een voorbeeld van een taak met een onvoldoende afbakening: 'Zorg dat het uploaden werkt'. Dit voorbeeld bevat geen bruikbare richtlijnen over wat 'werken' betekent of welke onderdelen erbij betrokken zijn.

Hier volgt een voorbeeld van een te beschrijvende taak: 'Voeg op regel 47 van DocumentsController.cs een methode met de naam UploadDocument toe met parameters (IFormFile-bestand, userId van tekenreeks) en implementeer deze met behulp van precies deze stappen...' Deze taakbeschrijving verwijdert het ontwikkelaarsbureau en houdt geen rekening met de veranderende codestructuur.

Taakafhankelijkheden en sequentiëren

De taakvolgorde is van belang. Sommige taken moeten worden voltooid voordat anderen kunnen beginnen.

Wijzigingen in databaseschema's komen meestal eerst voor, omdat back-endcode afhankelijk is van het bestaan van het schema. Back-end API-eindpunten komen vóór front-end onderdelen die deze eindpunten aanroepen. Configuratie-instelling gaat vooraf aan code die gebruikmaakt van die configuratie. Testen wordt uitgevoerd nadat de geteste code bestaat.

De takenlijst moet worden gesequentieerd om het blokkeren te minimaliseren. Als front-end- en back-endtaken onafhankelijk zijn, kunnen ze parallel doorgaan. Als er meerdere back-endeindpunten bestaan, kunnen ontwikkelaars de taken gelijktijdig implementeren.

Voor de functie voor het uploaden van documenten zorgt de logische volgorde voor het volgende:

  1. Configuratie en database-installatie vinden eerst plaats (geen afhankelijkheden).
  2. Implementatie van back-end-API volgt de installatie van de database (afhankelijk van het schema).
  3. Front-endonderdelen volgen de API-implementatie (afhankelijk van bestaande eindpunten).
  4. Beveiligingsverharding vindt plaats na de basisfunctionaliteit (afhankelijk van het bestaan van code).
  5. Testen vindt plaats na alle implementaties (afhankelijk van voltooide code).

Deze takenreeks maakt continue voortgang mogelijk zonder te wachten tot niet-gerelateerd werk is voltooid.

Taken genereren met behulp van /speckit.tasks

GitHub Spec Kit genereert takenlijsten via de /speckit.tasks opdracht in GitHub Copilot Chat. Met deze opdracht worden zowel spec.md als plan.md verwerkt om een uitgebreide, geordende lijst met implementatietaken te produceren.

De AI analyseert de specificatie om te begrijpen wat er moet worden gebouwd, beoordeelt het plan om de architectuurbenadering te begrijpen en genereert taken die de kloof tussen deze documenten en de werkelijke code overbruggen. Het resulterende bestand tasks.md bevat genummerde of opsommingstekens, vaak ingedeeld in fasen voor complexe functies.

De opdracht voor het genereren van taken aanroepen

Open GitHub Copilot Chat in Visual Studio Code en voer /speckit.tasks in. GitHub Copilot verwerkt de specificatie en het plan om een gestructureerde takenlijst te genereren. Het generatieproces wordt doorgaans binnen enkele ogenblikken voltooid, waardoor een uitgebreide uitsplitsing van de implementatiewerkzaamheden wordt gemaakt.

De takenlijst neemt automatisch context over van uw specificatie en plan. Als het plan 'Azure Blob Storage gebruiken' aangeeft, bevatten de gegenereerde taken specifieke stappen voor het configureren van blobopslagverbindingen, het implementeren van uploadlogica en het verwerken van opslagfouten.

De takenlijst controleren en valideren

De takenlijst vereist kritieke controle om de volledigheid en juistheid te waarborgen.

Dekking van planelementen controleren

Vergelijk tasks.md systematisch met plan.md. Elke stap voor architectuurbeslissing en implementatie in het plan moet overeenkomen met een of meer taken.

Als in het plan 'validatie aan de serverzijde wordt geïmplementeerd', moeten specifieke taken betrekking hebben op validatie van bestandstypen, validatie van bestandsgrootte en afhandeling van foutreacties. Als in het plan 'auditlogboek' wordt vermeld, moet een taak betrekking hebben op het maken van logvermeldingen voor uploadactiviteiten.

Ontbrekende taken geven onvolledige generatie- of planelementen aan die niet worden omgezet in concrete werkzaamheden. Los dit probleem op door taken handmatig toe te voegen of meer context te bieden en opnieuw te genereren.

Controleer op logische hiaten

Zoek naar functionaliteitsverschillen die niet duidelijk zijn uit het plan, maar worden duidelijk wanneer u implementatiedetails overweegt.

Veelvoorkomende hiaten zijn:

  • Foutafhandeling: Zijn er taken voor het afhandelen van netwerkfouten, opslagfouten of databaseproblemen?
  • Edge-gevallen: Wat gebeurt er wanneer gebruikers bestanden uploaden met identieke namen? Hoe worden gelijktijdige uploads verwerkt?
  • Configuratie: Zijn verbindingsreeksen, API-sleutels en service-eindpunten correct geconfigureerd?
  • Feedback van gebruikers: Hoe weten gebruikers wanneer het uploaden is voltooid of mislukt?
  • Gegevens opschonen: Als het uploaden gedeeltelijk lukt en vervolgens mislukt, wordt het opschonen dan uitgevoerd?

Identificeer deze hiaten tijdens de beoordeling en voeg de juiste taken toe voordat de implementatie begint.

Taakvolgorde en afhankelijkheden evalueren

Controleer of taken op de juiste wijze zijn gesequentieerd. Databaseschemataken moeten voorafgaan aan code die toegang heeft tot deze tabellen. API-eindpunttaken moeten voorafgaan aan front-endonderdelen die deze eindpunten aanroepen.

Als u taken uit volgorde vindt, kunt u ze handmatig herschikken. Als een front-endtaak bijvoorbeeld wordt weergegeven vóór de bijbehorende back-endtaak, verplaatst u deze naar de juiste fase.

Overweeg afhankelijkheden tussen taken binnen dezelfde fase. Als de uitvoer van een taak vereist is voor een andere taak, moet u ervoor zorgen dat de eerste taak eerder in de reeks wordt weergegeven.

Taakgranulariteit valideren

Zorg ervoor dat elke taak goed is afgebakend. Taken die te groot zijn ('volledige back-end implementeren') moeten worden opgesplitst in kleinere, beheerbare onderdelen. Taken die te klein zijn ('puntkomma toevoegen aan regel 42') moeten worden gecombineerd tot zinvollere eenheden.

Een goed omschreven taak duurt meestal een paar uur tot een dag om af te ronden, kan onafhankelijk getest worden en levert aantoonbare voortgang op.

Taken gebruiken om implementatie te begeleiden

Nadat de implementatie is gevalideerd, wordt tasks.md uw implementatieschema.

Systematische afhandeling van taken

Werk taken in de gewenste volgorde door, waarbij u ze voltooit voordat u naar de volgende gaat. Deze gedisciplineerde benadering zorgt ervoor dat er niets wordt overgeslagen en dat er duidelijke voortgangsindicatoren worden geboden.

Wanneer u elke taak voltooit:

  1. Implementeer de vereiste functionaliteit.
  2. Test de implementatie om de juistheid te controleren.
  3. Markeer de taak als voltooid (voeg een selectievakje of doorhalen toe).
  4. Voer uw wijzigingen door met een verwijzing naar de taak.

Deze systematische benadering maakt een duidelijke audittrail die voltooid werk aan specifieke taken koppelt.

Voortgang bijhouden en status communiceren

De takenlijst biedt een objectieve meting van de voortgang. Als 15 van 30 taken zijn voltooid, is de functie ongeveer 50% geïmplementeerd. Deze metrische waarde helpt bij projectplanning en communicatie met belanghebbenden.

Deel tasks.md met uw team om te communiceren wat er volledig is en wat er nog overblijft. Teamleden kunnen in één oogopslag zien welke gebieden aandacht nodig hebben en waar ze zich moeten richten op de beoordelingsinspanningen.

Taken aanpassen tijdens de implementatie

Als de implementatie nieuwe vereisten of betere benaderingen aangeeft, werkt u tasks.md dienovereenkomstig bij. De takenlijst moet de realiteit weerspiegelen, niet een verouderd plan.

Taken verdelen over teamleden

Duidelijke taakdefinities maken de werkverdeling mogelijk onder meerdere ontwikkelaars. Het back-endteam kan aan API-taken werken terwijl het front-endteam UI-onderdelen bouwt. Databasebeheerders kunnen schema's instellen terwijl ontwikkelaars configuratie voorbereiden.

Het expliciet aanroepen van taakafhankelijkheden helpt om blokkeren te voorkomen. Als taak B afhankelijk is van taak A, moet u ervoor zorgen dat taak A op de juiste wijze wordt toegewezen en prioriteit krijgt. Voltooiingscriteria voor documentatie in taken om ervoor te zorgen dat overgangen vlekkeloos zijn.

Code genereren met behulp van /speckit.implement

De /speckit.implement opdracht maakt gebruik van tasks.md om code systematisch te genereren. In plaats van volledige functionaliteiten in één keer te implementeren, werkt de AI de taken in volgorde af. Deze benadering produceert meer gerichte, juiste code.

U kunt aanroepen /speckit.implement met een specifiek taaknummer, een reeks taken of een beschrijving van de implementatie die uit het tasks.md-bestand is genomen. De AI verwijst naar spec.md, plan.md en tasks.md om code te produceren die overeenkomt met de algehele architectuur en vereisten.

Als u bijvoorbeeld het eindpunt voor het uploaden van documenten wilt implementeren, kunt u het volgende invoeren:

/speckit.implement Implement the MVP first strategy (Tasks: T001 - T027)

Met deze opdracht wordt de AI geïnstrueerd om te focussen op taken T001 tot en met T027, waarbij code wordt gegenereerd die voldoet aan de vereisten van elke taak in volgorde.

Hulp bieden tijdens de implementatie

De AI vereist mogelijk hulp of toestemming om door te gaan met bepaalde taken. Als voor een taak bijvoorbeeld het bouwen of uitvoeren van de app is vereist, kan de AI om bevestiging vragen voordat u doorgaat.

Bovendien kan de AI een fout detecteren bij het testen van de implementatie van een taak. Geef gedetailleerde informatie op om het probleem te diagnosticeren. U kunt ook extra context of verduidelijkingen bieden als de AI dubbelzinnigheid tegenkomt.

Wanneer u wordt gevraagd om hulp in de chatweergave, kunt u snel reageren om de implementatie soepel te laten verlopen.

Controlepunten voor verificatie

Nadat u een implementatieopdracht hebt voltooid, controleert u de resultaten voordat u doorgaat. Voer de toepassing uit, voer tests uit en controleer of elke taak is geïmplementeerd en of het doel ervan is bereikt. Deze incrementele verificatie onderschept problemen vroeg wanneer ze het eenvoudigst kunnen worden opgelost.

Contextonderhoud voor taken

Tijdens het doorlopen van taken biedt eerder voltooid werk context voor volgende taken. De AI kan verwijzen naar eerdere implementaties bij het bouwen van gerelateerde functionaliteit, het verbeteren van de codekwaliteit en het onderhouden van architectuurconsistentie.

Veelvoorkomende uitdagingen ontstaan bij het beheren van implementatietaken.

Taken die in omvang groeien

Wanneer een taak onverwachte complexiteit tijdens de implementatie aangeeft, pauzeert en herassetst u deze. Deel de opgeblazen taak in meerdere kleinere taken. Werk tasks.md bij om het werkelijke bereik weer te geven. Communiceer de bereikuitbreiding met belanghebbenden.

Geblokkeerde taken

Taken worden soms geblokkeerd door externe afhankelijkheden. Markeer geblokkeerde taken expliciet in tasks.md met blokkeringsredenen: 'BLOCKED: Waiting for Azure Blob Storage container provisioning - ticket #1234'. Houd geblokkeerde taken afzonderlijk bij om ervoor te zorgen dat ze niet vergeten worden.

Prioriteiten wijzigen

Bedrijfsbehoeften ontwikkelen zich. Wanneer prioriteiten verschuiven, werkt u tasks.md dienovereenkomstig bij. Uw taken opnieuw ordenen op een manier die nieuwe prioriteiten weerspiegelt. Voeg nieuwe taken toe voor opkomende vereisten. Overweeg taken uit te stellen of te verwijderen die niet langer waardevol zijn.

Dubbelzinnigheid van taken gedetecteerd tijdens de implementatie

Wanneer dubbelzinnigheid opduikt, pauzeert u de implementatie en zoekt u verduidelijking. Bekijk de specificatie en plan om de oorspronkelijke intentie te begrijpen. Werk de taakbeschrijving bij met specifieke, ondubbelzinnige taal voordat u doorgaat.

Samenvatting

Het genereren van taken transformeert architectuurplannen in bruikbare implementatiestappen. Taaklijsten genereren met /speckit.tasks gestructureerde uitsplitsingen van implementatiewerk per fase. Bekijk gegenereerde taken kritiek om uitgebreide dekking, logische sequentiëren en de juiste granulariteit te garanderen. Gebruik de gevalideerde takenlijst om systematische implementatie te begeleiden, voortgang bij te houden en teaminspanningen te coördineren.

De combinatie van spec.md, plan.md en tasks.md maakt een volledig ontwikkelframework. De specificatie definieert wat er moet worden gebouwd en waarom. Het plan definieert hoe u het architectonisch ontwerp maakt. De taken definiëren de specifieke stappen voor het uitvoeren van de build. Samen transformeren deze artefacten dubbelzinnige vereisten in concrete, traceerbare ontwikkelingswerkzaamheden die de afstemming met projectdoelen tijdens de implementatie behouden.