Hur man använder AI OpenHands: En praktisk guide till installation, prompter och verkliga arbetsflöden
Om du någonsin önskat att en kapabel utvecklare kunde parkoda med dig dygnet runt, kommer AI OpenHands slående nära. Det är en "AI-ingenjör" med öppen källkod som kan läsa din repo, skriva kod, köra terminaler, bläddra i dokument och iterera – precis som en junior utvecklare som lär sig snabbt och arbetar outtröttligt. Men kraften klickar först när du ställer in den korrekt och lär dig att styra den.
Den här guiden går igenom hur du använder AI OpenHands steg för steg – från installation till avancerade arbetsflöden – så att du kan leverera snabbare med självförtroende.
- Installationsalternativ och snabbstart
- Köra OpenHands lokalt eller med molnmodeller
- Bästa metoder för prompter, repos och uppgifter
- Beprövade arbetsflöden för funktionsarbete, felsökning, tester och dokument
- Skyddsräcken, integritet och samarbete
Värt att notera: OpenHands utvecklas aktivt av All Hands-teamet och communityn. Den officiella dokumentationen är din ledstjärna för aktuella instruktioner och tips. Du kan också följa praktiska installationsguider från utövare som har dokumenterat lokala och VM-installationer. För körning med lokala modeller innehåller dokumentationen också specifik vägledning.
Vad är AI OpenHands – och varför använda det?
Tänk på AI OpenHands som en AI-lagkamrat med ett tangentbord. Till skillnad från chattbaserade assistenter kan OpenHands:
- Öppna och läsa projektfiler
- Använda en terminal för att köra kommandon, tester och linters
- Redigera kod över filer och kataloger
- Surfa på webben (beroende på konfiguration)
- Föreslå och tillämpa stegvisa planer
Detta gör det idealiskt för uppgifter som att implementera funktioner, fixa buggar, skriva tester, skapa dokument, refaktorera och modernisera kodbaser. Istället för att jonglera med prompter och kopiera/klistra in, ger du OpenHands ett mål och låter det iterera, medan du övervakar dess rörelser.
Snabbstart: Det snabbaste sättet att använda OpenHands
Det finns flera sätt att komma igång. Ditt val beror på om du vill använda en moln-LLM eller köra allt lokalt.
Alternativ A: Använd en moln-LLM (enklast)
- Följ de officiella dokumenten "Start Building" och "Getting Started" för att installera och köra appen. Du kommer vanligtvis att:
- Installera förutsättningar (Docker, Node, Python, Git beroende på sökvägen)
- Ange en API-nyckel för en modell i molnet som stöds (t.ex. OpenAI, Anthropic eller andra som projektet stöder vid tidpunkten)
- Starta OpenHands-gränssnittet och anslut din repository
Den här vägen får dig produktiv snabbt med minimal beräkningskostnad.
Alternativ B: Kör OpenHands med en lokal LLM
- Om du föredrar att hålla kod och prompter utanför molnet eller vill undvika API-kostnader, använd guiden Local LLMs i den officiella dokumentationen.
- Konfigurera en kompatibel lokal modell (via Ollama eller andra backends som stöds vid tidpunkten)
- Konfigurera modellslutpunkter och kontextgränser
- Se till att din maskin har tillräckligt med VRAM/CPU och diskutrymme
Alternativ C: Distribuera till en VM
- Om du behöver en dedikerad miljö har utövare dokumenterat hur man snurrar upp OpenHands på en VM och bygger en app på några minuter. Detta är användbart för team som vill ha en stabil, delad AI-ingenjörsinstans.
Första körningen: Projektinställning och uppgiftsformulering
OpenHands glänser när den kan se din kod. Börja med att:
- Öppna den repository du vill att den ska arbeta med.
- Köra eller indexera projektet så att OpenHands kan kartlägga strukturen.
- Ge den ett tydligt mål med begränsningar.
Bra exempel på uppgiftsformulering:
- "Lägg till återställning av användarlösenord till tjänsten
auth med hjälp av tokenbaserade e-postlänkar. Använd befintlig modul mailer. Lägg till enhetstester för tokengenerering och förfallotid. Ändra inte användardataschemat."
Varför detta fungerar:
- Det namnger komponenten, omfattningen, beroenden och gränser. Ju tydligare du är, desto bättre planerar och utför OpenHands.
Hur man skriver effektiva prompter för OpenHands
Tänk på prompter som kortfattade ärenden. De bästa:
- Definiera resultatet: "Implementera X med Y-begränsningar"
- Referera filer, moduler eller tester: "Se
auth/routes.py och tests/test_auth.py"
- Ange begränsningar: "Inga DB-schemaändringar; behåll befintliga gränssnitt"
- Inkludera acceptanskriterier: "Tester ska klara:
pytest -k password_reset"
Mall du kan återanvända:
Mål: <Vad du vill bygga eller fixa>
Kontext: <Relevanta filer, kända begränsningar, externa tjänster>
Acceptans: <Hur godkänt ser ut: tester, slutpunkter, mätvärden>
Gränser: <Vad man inte ska ändra eller metoder att undvika>
Verktyg: <Kommandon det kan köra, skript eller datakällor>
Kärnarbetsflöde: Planera → Utför → Verifiera → Förfina
OpenHands föreslår vanligtvis en plan i flera steg. Så här guidar du den:
- Godkänn eller justera dess plan tidigt. Tvinga den att köra tester först för att baslinjera fel.
- Be den skapa eller uppdatera ett test för att definiera framgång, och implementera sedan koden.
- Låt den köra testsviten och linters ofta.
- Om den stannar, lägg till mer sammanhang: filnamn, stackspårningar eller loggar.
Proffstips: Uppmuntra små PR-storleksändringar istället för monolitiska redigeringar. Detta hjälper till med granskningsbarhet och återställning.
Exempel på arbetsflöden du kan kopiera
1) Funktionsimplementering
- Prompt: "Lägg till CSV-export till sidan
orders. Använd serversidig paginering, strömma resultat via text/csv. Lägg till knappen Export i OrdersTable.jsx och slutpunkten i routes/orders.ts. Inkludera tester för paginering och rubriker."
- Skannar repo; utarbetar plan
- Lägger till slutpunkt och klientknapp
- Skriver tester och kör dem
- Du övervakar, godkänner ändringar och slår samman när det är grönt.
2) Felsökning av en misslyckad version
- Prompt: "CI misslyckas på Node 20. Fixa ESM/CJS-importfel i
build.mjs. Behåll befintliga rollup-plugins; uppdatera konfiguration och kod för att klara CI."
- Ange loggar eller länk till CI-artefakter.
- Be OpenHands att replikera lokalt (
npm run build) och föreslå minimala skillnader.
3) Testtäckning och härdning
- Prompt: "Öka täckningen för
payments/service.py från 62 % till 85 %+. Lägg till enhetstester för retry_charge, refund, webhook_signature. Modifiera inte affärslogiken om inte testet avslöjar en bugg."
- Låt OpenHands generera tester, köra dem och förfina.
4) Dokument och utvecklarupplevelse
- Prompt: "Skapa en
CONTRIBUTING.md och DEVELOPMENT.md för den här repo. Inkludera miljöinställningar, skript, testkommandon och PR-riktlinjer."
- Låt den verifiera kommandon genom att faktiskt köra dem.
Skyddsräcken: Håll OpenHands hjälpsam och säker
- Katalogomfång: Peka den på en specifik repo eller katalog för att undvika oavsiktliga redigeringar någon annanstans.
- Filskydd: Markera konfigurationsfiler eller kritisk infrastruktur som skrivskyddade där det är möjligt.
- Kommandogranskning: Kräv godkännande för destruktiva kommandon (t.ex.
rm -rf, databasåterställningar).
- Hemlig hygien: Klistra aldrig in API-nycklar i prompter. Använd miljövariabler och maskerade loggar.
- Nätverksåtkomst: Om surfning är aktiverat, sandlåda det och logga utgående samtal.
Lokala vs molnmodeller: Välja vad som är rätt för dig
- Fördelar: Stark resonemang/kodning, minimal installation, snabb iteration
- Nackdelar: Löpande kostnad, överväganden om datastyrning
- Fördelar: Integritet, kontroll, kostnadsförutsägbarhet
- Nackdelar: Hårdvarukrav, modellkvaliteten varierar, mer finjustering behövs
Se de officiella Local LLMs-instruktionerna för att konfigurera modellbackends och minnesgränser.
Lagspel: Använda OpenHands i ett samarbetsflöde
- Gren-först-arbetsflöde: Låt OpenHands skapa en funktionsgren och pusha ändringar för PR-granskning.
- Commit-hygien: Be den producera atomiska commits med tydliga meddelanden och referensärendenummer.
- PR-mallar: Generera och tillämpa PR-mallar så att granskare vet vad som har ändrats och varför.
- Kodägare: Kombinera med CODEOWNERS för att dirigera AI-genererade PR till rätt granskare.
Felsökning av vanliga problem
- Den fastnar eller loopar: Begränsa omfattningen. Be den förklara sitt nästa steg. Ange ett misslyckat test.
- Röriga skillnader: Begär en mindre, iscensatt plan – tester först, sedan minimala kodändringar.
- Felaktiga filredigeringar: Ange exakta sökvägar och påminn den om gränser.
- Klarar lokalt men misslyckas i CI: Dela CI-miljöinformation och loggar; låt den replikera med en container.
Prestandatips och kraftdrag
- Varmstartkontext: Be den att läsa viktiga filer först (
README, package.json, huvudsakliga tjänstfiler).
- Ge den skript: Ange en
make test eller npm run verify så att den kan validera snabbt.
- Lär ut domänen: Erbjud en kort arkitektonisk översikt; det lönar sig i färre logikfel.
- Tillämpa stil: Peka på
.eslintrc, .prettierrc, black/ruff configs så att den formaterar korrekt.
- Använd checkpoints: Efter varje milstolpe, be om en sammanfattning och nästa steg för att hålla den på rätt spår.
Verkligt scenario: Från felrapport till patch på en timme
- Situation: En produktionsbugg släpper ohanterade 500-fel på felaktiga JSON-nyttolaster i
orders API.
- Din prompt: "Reproducera 500-felet på felaktig JSON i
orders POST. Lägg till schemavalidering och returnera 400 med feldetaljer. Uppdatera tester för att täcka felaktiga nyttolaster."
- Kör API:et lokalt, återskapar felet
- Lägger till ett valideringslager och felhanterare
- Uppdaterar tester och säkerställer att CI klarar sig
- Producerar en kompakt PR med en changelog-post
Sparad tid: Du fokuserade på konsekvensanalys och utrullning, medan OpenHands hanterade byggnadsställningen.
Integrationer som superladdar OpenHands
- Test runners: pytest, Jest, Vitest, JUnit
- Build tools: Vite, Webpack, Rollup, Babel
- Package managers: npm, pnpm, yarn, pip/poetry
- Linters/formatters: ESLint, Prettier, black, ruff
- Containers: Docker Compose för lokal paritet med CI
Genom att standardisera dessa verktyg kan OpenHands resonera om din stack mer tillförlitligt och automatisera mer av dev-loopen.
Förresten: Använda Sider.AI tillsammans med OpenHands
Relevanspoäng: 8/10. Om du använder OpenHands som din AI-ingenjör är det värt att para ihop den med en forsknings- och utkastskopilot för specifikationer, PR-beskrivningar och dokumentation. Förresten, Sider.AI kan hjälpa dig att snabbt utarbeta tekniska specifikationer, sammanfatta RFC:er eller omvandla OpenHands-körningsloggar till rena changeloggar och release notes. Kombinationen minskar kontextväxlingen: OpenHands hanterar kodåtgärder medan Sider.AI förvandlar resultat till rena, användarvända dokument.
Checklista för säkerhet, integritet och efterlevnad
- Förvara hemligheter i env vars; bädda aldrig in nycklar i prompter
- Granska varje AI-genererad ändring som du skulle göra med en juniorutvecklares PR
- Logga kommandon och åtgärder för granskningsbarhet
- Fäst toolchain-versioner; undvik oavsiktliga uppgraderingar i lockfiles
- Om du använder moln-LLM, anpassa dig till dina datalagringspolicyer
När du inte ska använda OpenHands
- Ny algoritmdesign utan stark test- eller specifikationsställning
- Mycket reglerade kodbaser utan en robust granskningsprocess
- Engångsskript där manuell kodning är snabbare
Dina första 60 minuter med OpenHands: En minispelbok
- Minut 0–10: Installera och starta med den officiella snabbstarten
- Minut 10–20: Anslut din repo; be den kartlägga projektstrukturen
- Minut 20–35: Definiera ett litet, testbart mål; godkänn dess plan
- Minut 35–50: Låt den implementera och köra tester; knuffa vid behov
- Minut 50–60: Granska skillnader, förfina och slå samman till en funktionsgren
Viktiga länkar och nästa steg
- Officiella "Start Building" och användningsdokument för OpenHands: tips, snabbstart och bästa metoder.
- Lokal LLM-installationsguide: konfigurera och kör OpenHands helt på din maskin.
- Community-driven installationsgenomgång på en VM: verkliga installationssteg och ett snabbt demoprojekt.
Slutsatser
- Formulera uppgifter som ärenden med tydliga acceptanskriterier.
- Håll iterationerna små; testa tidigt och ofta.
- Använd skyddsräcken och granska ändringar – behandla det som en junior lagkamrat.
- Välj moln för bekvämlighet, lokala modeller för integritet.
- Para ihop med dokumentationsverktyg (t.ex. Sider.AI) för att påskynda specifikationer och release notes.
FAQ
F1:Hur installerar jag och börjar använda AI OpenHands snabbt?
Använd den officiella snabbstarten för att installera förutsättningar, koppla in en LLM som stöds (moln eller lokal) och starta användargränssnittet för att ansluta din repository. Dokumenten "Start Building" innehåller steg-för-steg-instruktioner med installationstips.
F2:Kan jag köra OpenHands med en lokal LLM istället för en molnmodell?
Ja. Följ Local LLMs-guiden för att konfigurera en lokal modellbackend och justera kontextinställningar. Detta är idealiskt för integritetskänsliga projekt eller för att undvika API-kostnader.
F3:Vad är det bästa sättet att fråga OpenHands om kodningsuppgifter?
Skriv prompter som kortfattade ärenden: definiera målet, referera specifika filer, ange gränser och inkludera acceptanskriterier. Be den skapa eller köra tester för att validera framsteg.
F4:Är AI OpenHands säker att använda på produktionskod?
Behandla den som en juniorutvecklare: använd grenskydd, kodgranskning och CI för att validera ändringar. Lägg till skyddsräcken för kommandon och håll hemligheter utanför prompter.
F5:Hur jämförs OpenHands med en traditionell kodassistent?
Till skillnad från chattverktyg kan OpenHands köra kommandon, redigera filer och iterera autonomt inom din repository. Den är byggd för end-to-end-uppgifter som funktioner, felsökning och tester.
