Hvordan bruke AI OpenHands: En praktisk guide til oppsett, prompter og virkelige arbeidsflyter
Hvis du noen gang har ønsket deg en dyktig utvikler som kunne drive parprogrammering med deg 24/7, kommer AI OpenHands slående nær. Det er en åpen kildekode "AI-ingeniør" som kan lese repoen din, skrive kode, kjøre terminaler, bla gjennom dokumenter og iterere – omtrent som en juniorutvikler som lærer raskt og jobber utrettelig. Men kraften klikker først når du setter den opp riktig og lærer hvordan du styrer den.
Denne guiden tar deg gjennom hvordan du bruker AI OpenHands trinn for trinn – fra installasjon til avanserte arbeidsflyter – slik at du kan levere raskere med selvtillit.
- Installasjonsalternativer og hurtigstart
- Kjøre OpenHands lokalt eller med skybaserte modeller
- Beste praksis for prompter, repoer og oppgaver
- Beviste arbeidsflyter for funksjonsarbeid, feilsøking, tester og dokumenter
- Sikkerhetsmekanismer, personvern og samarbeid
Verdt å merke seg: OpenHands er aktivt utviklet av All Hands-teamet og fellesskapet. De offisielle dokumentene er din ledestjerne for gjeldende instruksjoner og tips. Du kan også følge praktiske installasjonsveiledninger fra praktikere som har dokumentert lokale og VM-oppsett. For kjøring med lokale modeller inkluderer dokumentene også spesifikk veiledning.
Hva er AI OpenHands – og hvorfor bruke det?
Tenk på AI OpenHands som en AI-teamkamerat med et tastatur. I motsetning til chat-baserte assistenter, kan OpenHands:
- Åpne og lese prosjektfiler
- Bruke en terminal for å kjøre kommandoer, tester og linters
- Redigere kode på tvers av filer og mapper
- Surfe på nettet (avhengig av konfigurasjon)
- Foreslå og anvende trinnvise planer
Dette gjør det ideelt for oppgaver som å implementere funksjoner, fikse feil, skrive tester, lage dokumenter, refaktorere og modernisere kodebaser. I stedet for å sjonglere prompter og kopiere/lime inn, gir du OpenHands et mål og lar det iterere, mens du overvåker bevegelsene.
Hurtigstart: Den raskeste måten å bruke OpenHands
Det er flere måter å komme i gang. Valget ditt avhenger av om du vil bruke en skybasert LLM eller kjøre alt lokalt.
Alternativ A: Bruk en skybasert LLM (enklest)
- Følg de offisielle "Start Building"- og "Getting Started"-dokumentene for å installere og kjøre appen. Du vil vanligvis:
- Installere forhåndskrav (Docker, Node, Python, Git avhengig av banen)
- Oppgi en API-nøkkel for en støttet skybasert modell (f.eks. OpenAI, Anthropic eller andre prosjektet støtter på det tidspunktet)
- Starte OpenHands-grensesnittet og koble til repositoryet ditt
Denne banen får deg raskt i gang med minimal databehandling.
Alternativ B: Kjør OpenHands med en lokal LLM
- Hvis du foretrekker å holde kode og prompter utenfor skyen eller ønsker å unngå API-kostnader, bruk Local LLMs-guiden i de offisielle dokumentene.
- Sette opp en kompatibel lokal modell (via Ollama eller andre backender som støttes på det tidspunktet)
- Konfigurere modellendepunkter og kontekstgrenser
- Sørge for at maskinen din har tilstrekkelig VRAM/CPU og diskplass
Alternativ C: Distribuer til en VM
- Hvis du trenger et dedikert miljø, har praktikere dokumentert hvordan du kan spinne opp OpenHands på en VM og bygge en app på få minutter. Dette er nyttig for team som ønsker en stabil, delt AI-ingeniørinstans.
Første kjøring: Prosjektoppsett og oppgaveinnramming
OpenHands skinner når den kan se koden din. Start med å:
- Åpne repositoryet du vil at den skal jobbe med.
- Kjøre eller indeksere prosjektet slik at OpenHands kan kartlegge strukturen.
- Gi den et tydelig mål med begrensninger.
Godt eksempel på oppgaveinnramming:
- "Legg til tilbakestilling av brukerpassord til
auth-tjenesten ved hjelp av token-baserte e-postlenker. Bruk eksisterende mailer-modul. Legg til enhetstester for tokengenerering og utløp. Ikke endre brukerskjemaet."
Hvorfor dette fungerer:
- Det navngir komponenten, omfanget, avhengighetene og grensene. Jo tydeligere du er, desto bedre planlegger og utfører OpenHands.
Hvordan skrive effektive prompter for OpenHands
Tenk på prompter som konsise oppgaver. De beste:
- Definerer resultatet: "Implementer X med Y-begrensninger"
- Refererer til filer, moduler eller tester: "Se
auth/routes.py og tests/test_auth.py"
- Angir begrensninger: "Ingen DB-skjemaendringer; behold eksisterende grensesnitt"
- Inkluderer akseptkriterier: "Tester skal bestå:
pytest -k password_reset"
Mal du kan gjenbruke:
Mål: <Hva du vil bygge eller fikse>
Kontekst: <Relevante filer, kjente begrensninger, eksterne tjenester>
Aksept: <Hvordan godkjent ser ut: tester, endepunkter, metrikker>
Grenser: <Hva du ikke skal endre eller tilnærminger du bør unngå>
Verktøy: <Kommandoer den kan kjøre, skript eller datakilder>
Kjerne arbeidsflyt: Planlegg → Utfør → Verifiser → Forbedre
OpenHands foreslår vanligvis en plan i flere trinn. Slik guider du den:
- Godkjenn eller juster planen tidlig. Press den til å kjøre tester først for å baseline feil.
- Be den opprette eller oppdatere en test for å definere suksess, og implementer deretter koden.
- Få den til å kjøre testsuiten og linters ofte.
- Hvis den stopper, legg til mer kontekst: filnavn, stack traces eller logger.
Pro-tips: Oppmuntre til små PR-størrelse endringer i stedet for monolittiske redigeringer. Dette hjelper med gjennomgang og tilbaketrekking.
Eksempelarbeidsflyter du kan kopiere
1) Funksjonsimplementering
- Prompt: "Legg til CSV-eksport til
orders-siden. Bruk server-side paginering, strøm resultater via text/csv. Legg til Export-knapp i OrdersTable.jsx og endepunkt i routes/orders.ts. Inkluder tester for paginering og overskrifter."
- Skanner repo; utarbeider plan
- Legger til endepunkt og klientknapp
- Skriver tester og kjører dem
- Du overvåker, godkjenner endringer og slår sammen når alt er grønt.
2) Feilsøking av en mislykket bygging
- Prompt: "CI mislykkes på Node 20. Fiks ESM/CJS importfeil i
build.mjs. Behold eksisterende rollup-plugins; oppdater konfigurasjon og kode for å bestå CI."
- Gi logger eller lenke til CI-artefakter.
- Be OpenHands replikere lokalt (
npm run build) og foreslå minimale diffs.
3) Testdekning og herding
- Prompt: "Øk dekningen for
payments/service.py fra 62% til 85%+. Legg til enhetstester for retry_charge, refund, webhook_signature. Ikke endre forretningslogikken med mindre testen avslører en feil."
- La OpenHands generere tester, kjøre dem og forbedre dem.
4) Dokumenter og utvikleropplevelse
- Prompt: "Opprett en
CONTRIBUTING.md og DEVELOPMENT.md for dette repoet. Inkluder miljøoppsett, skript, testkommandoer og PR-retningslinjer."
- Få den til å bekrefte kommandoer ved å faktisk kjøre dem.
Sikkerhetsmekanismer: Hold OpenHands hjelpsom og sikker
- Mappeomfang: Pek den på et spesifikt repo eller mappe for å unngå utilsiktede redigeringer andre steder.
- Filbeskyttelse: Marker konfigurasjonsfiler eller kritisk infrastruktur som skrivebeskyttet der det er mulig.
- Kommandoovervåking: Krever godkjenning for destruktive kommandoer (f.eks.
rm -rf, databasetilbakestillinger).
- Hemmelighold: Lim aldri inn API-nøkler i prompter. Bruk miljøvariabler og maskerte logger.
- Nettverkstilgang: Hvis surfing er aktivert, sandboks den og logg utgående anrop.
Lokale vs. skybaserte modeller: Velge det som er riktig for deg
- Fordeler: Sterk resonnering/koding, minimalt oppsett, rask iterasjon
- Ulemper: Løpende kostnader, vurderinger av datastyring
- Fordeler: Personvern, kontroll, forutsigbarhet av kostnader
- Ulemper: Maskinvarekrav, modellkvaliteten varierer, mer justering er nødvendig
Se de offisielle Local LLMs-instruksjonene for å konfigurere modellbackends og minnebegrensninger.
Teamarbeid: Bruke OpenHands i en samarbeidsflyt
- Gren-først arbeidsflyt: Få OpenHands til å opprette en funksjonsgren og presse endringer for PR-gjennomgang.
- Commit hygiene: Be den produsere atomiske commits med klare meldinger og referansenummer.
- PR-maler: Generer og håndhev PR-maler slik at reviewers vet hva som er endret og hvorfor.
- Kodeeiere: Kombiner med CODEOWNERS for å rute AI-genererte PRs til de riktige reviewers.
Feilsøking av vanlige problemer
- Den setter seg fast eller går i løkker: Begrens omfanget. Be den forklare sitt neste trinn. Gi en mislykket test.
- Rotete diffs: Be om en mindre, trinnvis plan – tester først, deretter minimale kodeendringer.
- Feil filredigeringer: Spesifiser nøyaktige stier og minn den om grenser.
- Består lokalt, men mislykkes i CI: Del CI-miljødetaljer og logger; få den til å replikere med en container.
Ytelsestips og kraftgrep
- Varmstartkontekst: Be den lese nøkkelfiler først (
README, package.json, hovedtjenestefiler).
- Gi den skript: Gi et
make test eller npm run verify slik at den kan validere raskt.
- Lær bort domenet: Gi en kort arkitektonisk oversikt; det lønner seg i færre logikkfeil.
- Håndhev stil: Pek til
.eslintrc, .prettierrc, black/ruff-konfigurasjoner slik at den formaterer riktig.
- Bruk sjekkpunkter: Etter hver milepæl, be om et sammendrag og neste trinn for å holde den på sporet.
Virkelig scenario: Fra feilrapport til patch på en time
- Situasjon: En produksjonsfeil slipper uhåndterte 500-feil på feilformaterte JSON-payloads i
orders API.
- Din prompt: "Reproducer 500-feilen på feilformaterte JSON i
orders POST. Legg til skjema validering og returner 400 med feildetaljer. Oppdater tester for å dekke feilformaterte payloads."
- Kjører API lokalt, reproduserer feilen
- Legger til et valideringslag og feilhåndterer
- Oppdaterer tester og sikrer at CI består
- Produserer en kompakt PR med en changelog-oppføring
Tid spart: Du fokuserte på konsekvensanalyse og utrulling, mens OpenHands håndterte stillasbyggingen.
Integrasjoner som superlader OpenHands
- Test runners: pytest, Jest, Vitest, JUnit
- Byggeverktøy: Vite, Webpack, Rollup, Babel
- Pakkehåndterere: npm, pnpm, yarn, pip/poetry
- Linters/formaterere: ESLint, Prettier, black, ruff
- Containere: Docker Compose for lokal paritet med CI
Ved å standardisere disse verktøyene kan OpenHands resonnere om stabelen din mer pålitelig og automatisere mer av utviklingssløyfen.
Forresten: Bruke Sider.AI sammen med OpenHands
Relevansscore: 8/10. Hvis du bruker OpenHands som din AI-ingeniør, er det verdt å pare den med en forsknings- og utkastskopilot for spesifikasjoner, PR-beskrivelser og dokumentasjon. Forresten, Sider.AI kan hjelpe deg med å raskt utarbeide tekniske spesifikasjoner, oppsummere RFC-er eller transformere OpenHands-kjøringslogger til rene changelogs og release notes. Kombinasjonen reduserer kontekstbytte: OpenHands håndterer kodehandlinger mens Sider.AI gjør resultater om til rene, brukerrettede dokumenter.
Sikkerhets-, personvern- og samsvarskontrolliste
- Oppbevar hemmeligheter i env-variabler; aldri innebygde nøkler i prompter
- Gå gjennom hver AI-genererte endring slik du ville gjort med en juniorutviklers PR
- Logg kommandoer og handlinger for revisjon
- Fest verktøykjedeversjoner; unngå utilsiktede oppgraderinger i lockfiles
- Hvis du bruker skybaserte LLMer, juster med dine datalagringspolicyer
Når du ikke skal bruke OpenHands
- Ny algoritmedesign uten sterk test- eller spesifikasjonsstillas
- Sterkt regulerte kodebaser uten en robust gjennomgangsprosess
- Engangs skript der manuell koding er raskere
Dine første 60 minutter med OpenHands: En mini-spillebok
- Minutt 0–10: Installer og start ved hjelp av den offisielle hurtigstarten
- Minutt 10–20: Koble til repoet ditt; be den kartlegge prosjektstrukturen
- Minutt 20–35: Definer et lite, testbart mål; godkjenn planen
- Minutt 35–50: La den implementere og kjøre tester; gi et dytt ved behov
- Minutt 50–60: Gå gjennom diffs, forbedre og slå sammen til en funksjonsgren
Viktige lenker og neste trinn
- Offisielle "Start Building" og bruksdokumenter for OpenHands: tips, hurtigstart og beste praksis.
- Oppsettsguide for lokale LLMer: konfigurer og kjør OpenHands helt på maskinen din.
- Fellesskapsdrevet installasjonsgjennomgang på en VM: virkelige installasjonstrinn og et raskt demoprosjekt.
Viktige punkter
- Ramme inn oppgaver som oppgaver med klare akseptkriterier.
- Hold iterasjonene små; test tidlig og ofte.
- Bruk sikkerhetsmekanismer og gå gjennom endringer – behandle det som en junior-teamkamerat.
- Velg sky for bekvemmelighet, lokale modeller for personvern.
- Par med dokumentasjonsverktøy (f.eks. Sider.AI) for å akselerere spesifikasjoner og release notes.
FAQ
Q1: Hvordan installerer jeg og begynner å bruke AI OpenHands raskt?
Bruk den offisielle hurtigstarten for å installere forhåndskrav, koble til en støttet LLM (skybasert eller lokal) og start brukergrensesnittet for å koble til repositoryet ditt. "Start Building"-dokumentene gir trinnvise instruksjoner med oppsettstips.
Q2: Kan jeg kjøre OpenHands med en lokal LLM i stedet for en skybasert modell?
Ja. Følg Local LLMs-guiden for å konfigurere en lokal modellbackend og justere kontekstinnstillinger. Dette er ideelt for personvernsensitive prosjekter eller for å unngå API-kostnader.
Q3: Hva er den beste måten å be OpenHands om kodings oppgaver?
Skriv prompter som konsise oppgaver: definer målet, referer til spesifikke filer, sett grenser og inkluder akseptkriterier. Be den om å opprette eller kjøre tester for å validere fremdriften.
Q4: Er AI OpenHands trygt å bruke på produksjonskode?
Behandle det som en juniorutvikler: bruk grenbeskyttelse, kodegjennomgang og CI for å validere endringer. Legg til sikkerhetsmekanismer for kommandoer og hold hemmeligheter utenfor prompter.
Q5: Hvordan sammenlignes OpenHands med en tradisjonell kodeassistent?
I motsetning til chat-only verktøy, kan OpenHands kjøre kommandoer, redigere filer og iterere autonomt i repoet ditt. Den er bygget for ende-til-ende-oppgaver som funksjoner, feilsøking og tester.
