Isang harnes para sa bawat gawain: dinamikong workflow sa Claude Code

Original na may-akda: @trq212

I-translate: Peggy

Editor's Note: Ang Claude Code ay nagiging isang actionable Agent workstation mula sa isang code assistant.

Ang mga workflow na ipinapakita sa artikulong ito ay may pangunahing halaga sa pagpapalaya sa Claude mula sa pagiging limitado sa pag-iisip at paggawa sa loob ng iisang kontekstwal na window; sa halip, maaari itong magbuo nang dinamiko ng isang framework para sa pagpapatupad: paghahati ng gawain, pagkakaloob ng mga sub-Agent, pagpapatakbo nang sabay-sabay, pagpapatotoo ng krus, pag-uulit sa loop, at kahit pagpapagana ng kompetisyon sa pagitan ng iba’t ibang Agent, bago ang mga resulta ay isama.

Ibig sabihin nito, ang mga pagkakataon sa paggamit ni Claude Code ay patuloy na lumalawak. Hindi ito limitado sa paglipat ng code, pagrerefactor, pagpapakita muli ng pagsubok, at pagrereview ng code, kundi maaari rin itong gamitin sa malalim na pag-aaral, pag-verify ng katotohanan, pagpili ng resume, pagrereview ng insidente, pagpapalawig ng mga patakaran, pagrereview ng business plan, at pag-brainstorm ng mga pangalan, sa mga gawain na hindi teknikal. Maraming kumplikadong gawain ay may katulad na kalikasan sa pag-program: kailangan ng paghahati ng problema, pag-isolate ng konteksto, pag-verify ng mga hipotesis, paghahandle ng maraming detalye, at pagpili sa pagitan ng maraming posibleng path.

Sinusubaybayan ng dynamic workflows ang ilang karaniwang problema sa mga malalaking modelo sa mahabang gawain: ang "agent laziness" na nagpapahayag ng pagkakatapos bago pa ito natatapos, ang "self-bias" na may tendensya na tanggapin ang sariling konklusyon, at ang "goal drift" na unti-unting lumalayo sa orihinal na layunin pagkatapos ng maraming pagpapatupad. Sa pamamagitan ng pagbibigay ng gawain sa maraming Claude na may sariling konteksto, binago nito ang kompleks na gawain mula sa "single-agent marathon" patungo sa "multi-agent collaboration".

Hindi rin ang workflows ang sagot sa lahat. Karaniwang nagdudulot ito ng mas maraming token, at hindi ito laging angkop para sa bawat pangkaraniwang gawain sa pag-code. Ngunit binibigay nito ang isang mahalagang direksyon: Ang pagkakaroon ng kompetisyon sa mga AI tool sa hinaharap ay maaaring hindi lamang batay sa kung gaano katalino ang isang modelo, kundi kung kaya nito na organisahin ang isang mapagkakatiwalaan, maaaring muli gamitin, at maaaring i-audit na proseso sa paligid ng mga kumplikadong layunin.

Narito ang orihinal:

Bagaman ang default na execution framework ng Claude Code ay binuo para sa programming, maaari itong gamitin din sa maraming iba pang uri ng gawain. Napatunayan na maraming gawain ay may magkakaparehong istruktura sa programming. Gayunpaman, upang makamit ang pinakamahusay na pagganap sa ilang partikular na uri ng gawain, kailangan pa rin nating bumuo ng custom execution framework sa itaas ng Claude Code, tulad ng pananaliksik, seguridad na analisis, pakikipagtulungan ng mga agent team, o code review.

Ang Workflows ay nagpapahintulot sa iyo na dinamikong lumikha ng isang framework para sa pagpapatupad, na nagpapahintulot sa Claude na mas natural na lutasin ang mga problema na ito at iba pang uri ng mga problema sa loob ng Claude Code. Maaari mo ring ibahagi at muli gamitin ang mga workflow na ito sa iba.

Sa artikulong ito, ibabahagi ko ang aking sariling karanasan at mga aral mula sa paggamit ng workflows, upang tulungan kang mas mabuti pang gamitin ang kakayahan nito.

Gayunpaman, kailangang paunlarin ang mga pinakamainam na pamamaraan. Ang mga dinamikong workflow ay karaniwang naglalabas ng higit pang mga token, kaya kailangan mong mabuti na isipin kung kailan at paano gamitin ito.

Tanda: Ipinapakita rin ang artikulong ito sa Claude Blog.

Halimbawang Prompt

Bago pumasok sa teknikal na detalye, gustong ibigay ko ang ilang halimbawang prompt upang tulungan ka na maunawaan ang mga posibilidad ng workflows:

Nababagol ang pagsubok na ito sa bawat 50 pagpapatakbo. Lumikha ng isang workflow upang muling ipakita ito, magbigay ng isang hypothesis, at magpatupad ng adversarial testing sa iba’t ibang worktree. /goal Huwag magpahinga hanggang sa matuklasan at patunayan ang isang hypothesis.

Gamitin ang workflow upang mabalikan ang aking 50 pinakabagong sesyon, makuha ang mga paulit-ulit kong pagkakamali, at isalin ang mga paulit-ulit na problema bilang mga patakaran sa CLAUDE.md.

Gumamit ng workflow upang suriin ang #incidents channel sa Slack sa nakalipas na anim na buwan at hanapin ang mga paulit-ulit na sanhi na walang isinumite na ticket.

Gumamit ng aking business plan para sa isang workflow, at hayaang magkakahiwalay ang iba’t ibang agent na i-decompose ito mula sa pananaw ng investor, customer, at kompetitor.

May isang folder na naglalaman ng 80 na resume. Gamitin ang workflow upang ayusin sila batay sa mga kahilingan para sa post na backend, at i-verify ang top ten. Gumamit ng AskUserQuestion tool upang magtanong sa akin at tulungan akong bumuo ng mga pamantayan sa pagtataya.

Kailangan kong magbigay ng pangalan sa ganitong CLI tool. Gamitin ang workflow upang mag-brainstorm ng mga opsyon, tapos piliin ang tatlong pinakamahusay gamit ang tournament mechanism.

Gamitin ang workflow upang muling pangalanan ang aming User model bilang Account sa lahat ng lugar.

Basahin ang aking draft ng blog at gamitin ang workflow upang i-verify ang bawat teknikal na pagpapasya sa codebase. Ayaw kong ipahayag ang anumang maling nilalaman.

Paano gumagana ang dynamic workflow

Ang dynamic workflow ay gagawin ang isang JavaScript file na naglalaman ng ilang espesyal na function para sa pagbuo at pag-coordinate ng mga sub-agent.

Ang dinamikong workflow ay naglalaman rin ng mga standard na JavaScript function tulad ng JSON, Math, at Array para sa pagproseso ng data.

Lalo na nakikita, ang dinamikong workflow ay maaaring matukoy kung anong model ang gagamitin ng isang agent, at kung ang mga sub-agent ay gagana sa kanilang sariling worktree. Ito ay nagpapahintulot sa Claude na piliin nang sarili ang kinakailangang antas ng inteligensya at antas ng paghihiwalay batay sa pangangailangan ng gawain.

Kung isinara ang isang workflow, halimbawa dahil sa manual na aksyon ng user o pag-exit ng terminal, maaaring magpatuloy ang workflow mula sa punto kung saan ito sinara pagkatapos ng pagbabalik ng session.

Kapag pinapagana mo ang default na Claude Code execution framework upang harapin ang isang gawain, kailangan nito na gawin ang pagpaplano at pagpapatupad sa parehong konteksto window. Para sa maraming programming tasks, sobrang epektibo ang paraang ito, ngunit sa mahabang panahon, malawakang paralelo, o mataas na istrakturadong adversarial tasks, minsan ito ay nababigo.

Dahil sa pagpapalawig ng oras na ginagamit ni Claude sa pagtratado ng mga kumplikadong gawain sa isang solong window ng konteksto, mas madaling makakaranas ito ng ilang partikular na anyo ng pagkabigo:

Ang agentic laziness (inteligenteng kahinaan) ay tumutukoy sa pagpapahinto ni Claude bago matapos ang isang napakakomplikadong gawain na may maraming bahagi, at pagsasabi na natapos na ito kahit na nagkaroon lamang ng bahagyang progreso. Halimbawa, sa isang pagsusuri sa kaligtasan, nagtratrabaho lamang sa 20 sa 50 mga proyekto at sinabi na natapos na ang trabaho.

Ang self-preferential bias (self-preferential bias) ay tumutukoy sa pagiging may-ugali ni Claude na paborin ang sariling mga resulta o natuklasan, lalo na kapag hinihingi na patunayan o husgahan ang sariling nilalabas na mga nilalaman batay sa isang set ng mga pamantayan.

Ang goal drift (pagkawala ng layunin) ay tumutukoy sa pagkabawas ng pagkakatapat ni Claude sa orihinal na layunin habang nagpapatupad sa maraming pagkakataon, lalo na pagkatapos ma-compress ang konteksto. Bawat pagsumaryo ay nagdudulot ng pagkawala ng impormasyon, at maaaring mawala ang ilang detalye tulad ng mga edge case o mga limitasyon tulad ng "huwag gawin ang X".

Ang paggawa ng workflow ay nakakatulong na malutas ang mga problema na ito, dahil ito ay maaaring mag-organisa ng maraming hiwalay na Claude, na may sariling window ng konteksto, at nakafokus sa mga layunin na magkaka-isa at malinaw.

Maaari mo nang nakabuo ng static workflow gamit ang Claude Agent SDK o claude -p upang mag-coordinate sa mga multiple Claude Code instances.

Ngunit dahil kailangan ng mga static workflow na sakop ang iba't ibang edge cases, karaniwang mas pangkalahatan sila. Kasama na ang Claude Opus 4.8 at dynamic workflows, sapat na matalino ang Claude upang sumulat ng isang custom execution framework para sa iyong partikular na use case.

Mga praktikal na pattern habang gumagamit ng dynamic workflow

Maaari mong direkta hingin kay Claude na lumikha ng isang dinamikong workflow, o gamitin ang trigger word na «ultracode» upang siguraduhing lumilikha ang Claude Code ng workflow.

Gayunpaman, kung makakabuo ka ng mental model kung paano gumagana ang dynamic workflow, mas madali mong matukoy kailan dapat gamitin ito at mas madali ring gabayan ang Claude sa pamamagitan ng prompt.

Ginagamit ni Claude ang mga sumusunod na pattern at pinagsasama nila kapag nagbuo ng workflows:

I-classify at pagsasagawa: Gamitin ang isang classification agent upang matukoy ang uri ng gawain, pagkatapos ay i-route sa iba’t ibang agent o pagkilos batay sa uri ng gawain. Maaari rin gamitin ang classifier sa dulo ng proseso upang matukoy ang output.

Split and aggregate: Ihiwalay ang isang gawain sa maraming mas maliit na hakbang, kung saan bawat hakbang ay trato ng isang agent, at pagkatapos ay i-aggregate ang mga resulta. Ang paraang ito ay partikular na epektibo para sa mga gawain na may malaking bilang ng maliit na hakbang, o kung kailangan ng bawat hakbang ng malinis na kontekstong window upang maiwasan ang pagkaka-interferensya o cross-contamination. Ang hakbang ng pag-aggregate ay tumutukoy sa isang “barrier”: ito ay hinihintay ang lahat ng mga agent na nagsplit upang matapos, at pagkatapos ay isasama nito ang kanilang structured output sa isang resulta.

Adversarial validation: Para sa bawat agent na nabuo, patakbuhin ang isang hiwalay na agent upang masuri ang output nito batay sa isang tiyak na pamantayan o prinsipyo.

Generate and filter: Lumikha ng maraming ideya sa paligid ng isang paksa, pagkatapos ay i-filter batay sa mga pamantayan sa pagtataya o proseso ng pagpapatotoo, tanggalin ang mga paulit-ulit, at ibalik lamang ang mga napatunayan at pinakamataas na kalidad na ideya.

Torneo: Huwag hatiin ang trabaho, kundi pagsikapan ng mga agent na magkaisa. Gumawa ng N mga agent at bigyan sila ng iba’t ibang paraan upang subukang matapos ang parehong gawain. Pagkatapos, gamitin ang prompt o modelo upang suriin at ihambing ang mga resulta ng mga agent nang pares-pares hanggang makakita ng tagumpay.

Ulitin hanggang matapos: Para sa mga gawain na ang dami ay hindi alam, huwag magtakda ng fixed na bilang ng round, kundi uulitin ang pagbuo ng agent hanggang matupad ang kondisyon ng paghinto, tulad ng pagkakaroon ng wala nang bagong natuklasan, o pagkakaroon ng wala nang error sa log.

Gamit na sitwasyon

Mas malikhaing isipin kung kailan at paano gagawin ni Claude Code ang mga dinamikong workflow. Natuklasan kong mas kapaki-pakinabang minsan ang workflows sa mga non-technical na gawain.

Gamit ni Bun ang workflows upang i-rewrite ang Zig sa Rust. Maaari mong basahin ang post ni Jarred sa X para sa detalyadong proseso.

Ang susi ay ang paghahati ng gawain sa isang serye ng mga hakbang na kailangang tratuhin, tulad ng mga point ng pagtawag, pagsubok sa pagkabigo, mga module, atbp. Mag-start ng isang sub-agent sa bawat pag-aayos sa worktree upang matapos nito ang pag-aayos; pagkatapos ay hayaan ang isa pang agent na magbigay ng kontrabida na pagsusuri, at huli ay i-merge ang mga resulta. Maaari mong i-clear sa agent na huwag gamitin ang mga utos na naglalabas ng maraming yaman, upang maksimuhin ang pagkakasunud-sunod at hindi mapagod ang lokal na machine.

Isinampa namin ang isang deep research skill (/deep-research) sa Claude Code, na gumagamit ng dynamic workflow. Sa partikular, ito ay magpapalawig upang isagawa ang web search, i-capture ang mga pinagkunan, mag-verify ng mga pahayag nang may pagtutol, at mag-isama upang lumikha ng isang report na may mga sanggunian.

Ngunit hindi lamang ito nagagamit sa paghahanap sa web. Halimbawa, maaari mo ring hilingin sa Claude na maghanda ng isang ulat ng kalagayan mula sa konteksto ng Slack, o pagsisiyasatin ang isang tampok kung paano ito gumagana sa pamamagitan ng malalim na pag-aaral sa codebase.

Sa kabilang panig, kung mayroon kang isang ulat at nais mong i-verify ang bawat factual claim at source na binanggit dito, maaari mong lumikha ng workflow: una ay ipagkakaloob sa isang agent ang pagkilala sa lahat ng factual claims, at pagkatapos ay i-trigger ang bawat claim sa isang sub-agent para sa detalyadong pagsusuri. Maaari mo ring ipagkaloob sa isang verification agent ang pag-check sa mga sub-agent na responsable sa pagkuha ng source, upang matiyak na sapat ang kalidad ng mga source nito.

Maaari mong mayroong isang set ng mga proyekto na nais mong ayusin batay sa isang kwalitatibong indikador, at naniniwala ka na ang Claude Code ay mahusay sa pag-evaluate ng ganitong uri ng indikador. Halimbawa, ayusin ang mga support ticket batay sa gravidad ng mga bug.

Ngunit kung subukan mong ayusin ang higit sa 1,000 na linya sa isang prompt, bababa ang kalidad at hindi makakasali sa window ng konteksto. Mas mabuting pagsabihan ang tournament mechanism, pagbuo ng isang pipeline ng mga agent na nagkukumpara sa magkakapares, dahil mas tiyak ang pagkukumpara kaysa sa absolute na pag-skor; o unang mag-parallel na bucket sort, tapos i-merge ang mga resulta. Bawat pagkukumpara ay ginagawa ng isang hiwalay na agent, kaya ang deterministikong loop ay maaaring panatilihin ang buong istruktura ng kompetisyon, at ang tanging order na kasalukuyang tumatakbo ang kailangang i-save sa konteksto.

Kung mayroon kang isang set ng mga partikular na patakaran, at madalas na nakakalimutan o hindi maayos na isinasagawa ni Claude kahit na nakikita niya ang mga patakaran sa CLAUDE.md, maaari mong lumikha ng isang workflow na listahan ang mga patakaran at ipagawa sa verification agent ang pag-check sa bawat patakaran—bawat patakaran ay may sariling verification agent. Ang paglikha ng isang sub-agent na may "skeptical" na pagkatao upang suriin kung ang mga patakaran ay makatotohanan ay nakakatulong din upang maiwasan ang sobrang false positives.

Maaari rin ito gawin sa kabaligtaran: hanapin ang mga pagkakamali na paulit-ulit mong inaayos mula sa iyong pinakabagong mga usapan at mga komento sa code review; i-klasipikahin ng parallel agent ang mga problema na ito; pagkatapos ay i-verify ang bawat kandidatong patakaran sa pamamagitan ng pagsubok laban sa mga tunay na pagkakamali upang matiyak kung talagang maiiwasan nito ang mga ito; at huling-huli, isauli ang mga patakaran na nakapasa sa pagsusuri pabalik sa CLAUDE.md.

Ang pinakaepektibong paraan ng pag-debug ay ang pagbuo ng ilang magkakaibang hipotesis at pagsubok sa bawat isa. Ngunit kung gagamitin mo lamang ang isang context window, maaaring maging biktima ng Claude ng sariling pagkakamali.

Ang workflow ay maaaring pigilan ang ganitong sitwasyon sa pamamagitan ng pagbuo ng mga estruktura: maaari itong mag-start ng maraming agent upang sila ay mag-generate ng mga hipotesis batay sa mga ebidensya na walang pagkakasalungat. Halimbawa, hayaan ang iba’t ibang agent na tingnan ang mga log, file, at data. Pagkatapos, bawat hipotesis ay maaaring masuri ng isang grupo ng mga validator at mga kritiko.

Hindi ito limitado sa code lamang. Maaari ring gamitin ang workflows sa pag-analisa ng mga benta, tulad ng “Bakit bumaba ang kita noong Marso?”; sa data engineering, tulad ng “Bakit nabigo ang pipeline na ito?”; o sa anumang pagrereview pagkatapos ng isang pangyayari.

Mayroong bawat team na may suportang queue, mga ulat ng bug, o iba pang mga gawain na hindi maaaring ganap na tratuhin ng tao. Ang isang workflow para sa triage ay maaaring magkategorya sa bawat item, mag-remove ng duplicate sa mga isyu na naka-track na, at mag-act. Maaari itong nangangahulugan ng pagsubok na ayusin, o pagtaas sa isang tao para sa pagtrato.

Para sa workflow ng triage, isang kapaki-pakinabang na pattern ay ang quarantine. Ibig sabihin, ipagbawal ang paggawa ng mga high-privilege operation ng mga agent na bumabasa ng hindi kapani-paniwalang publikong nilalaman; ang mga high-privilege operation ay dapat gawin ng mga espesyal na agent para sa aksyon.

Maaari mong gamitin ang triage workflows kasama ang /loop upang payagan ang Claude na magpatuloy na pagsagawa ng mga gawain na ito.

Ang workflows ay kapaki-pakinabang kapag kailangan mong suriin ang iba’t ibang landas ng solusyon, lalo na sa mga gawain na may kaugnayan sa disenyo at pangalan na may mga pagtataya na may estetika, at maaaring makatulong sa isang set ng pamantayan sa pagtataya.

Maaari mong hayaan ang Claude na suriin ang malaking bilang ng mga solusyon at ibigay sa审查 agent ang isang set ng mga pamantayan para sa「ano ang isang mabuting solusyon». Kapag naniniwala ang审查 agent na natutugunan na ng resulta ang mga pamantayan, tapos na ang gawain. Maaari ring ayusin o filtarin ang iba’t ibang solusyon gamit ang mga pamantayang ito sa pamamagitan ng isang tournament-style mechanism.

Maaari mong pagsimulan ang isang lightweight eval para sa isang partikular na gawain sa pamamagitan ng pagpapatakbo ng isang independent agent sa worktree, sumunod sa pagpapatakbo ng comparison agent, at paghahambing at pagmamarka ng output batay sa mga pamantayan. Halimbawa, maaari mong i-evaluate at i-improve ang isang skill na iyong nilikha upang tingnan kung ito ay sumasapat sa mga partikular na pamantayan.

Model at at intelligent routing: Maaari mong lumikha ng isang classification agent na tinatayong ang iyong sariling gawain, na magpapasya kung aling model ang gagamitin. Kapag ang gawain ay nagsasangkot ng maraming pagtawag sa mga tool, at ang pag-aaral bago ang pagsasagawa ay makakatulong upang matukoy ang pinakamahusay na model, ang paraang ito ay lubos na kapaki-pakinabang.

Halimbawa, para sa gawain na “Ipaliwanag kung paano gumagana ang auth module”, ang pinakamabisang modelo ay nakadepende sa bilang ng mga file sa auth module at sa istruktura ng codebase. Ang classification agent ay maaaring unang gawin ang pag-aaral na ito, at pagkatapos ay i-route ang gawain sa Sonnet o Opus batay sa inaasahang kumplikado.

Ang workflows ay patuloy na bagong bagay. Kahit na maaari itong magdala ng mas malaking epekto kaysa sa karaniwang paraan sa maraming paggamit, hindi bawat gawain ang nangangailangan nito, at maaari itong makapagdulot ng malaking pagtaas sa pagkakagastos ng token.

Gamitin ang workflows sa mga gawain na maaaring palawigin ang hangganan ng kakayahan ng Claude Code sa mga bagong paraan. Para sa karaniwang mga gawain sa pag-program, tanungin muna ang sarili mo: Kailangan ba talaga ng gawain na ito ng mas maraming mga mapagkukunan sa pagkalkula? Halimbawa, hindi kailangan ng karamihan sa mga tradisyonal na gawain sa pag-program ng isang grupo na binubuo ng 5 na tagapagsuri.

Mga tip sa pagbuo ng dinamikong workflow

Kapag sumusulat ng prompt para sa dynamic workflow, mas mabuti ang resulta kung mas detalyado ang impormasyon, lalo na kung gagamitin ang mga partikular na teknik na nabanggit sa itaas.

Hindi lamang ang mga workflow ay nagagamit para sa mga malalaking gawain. Maaari mo ring hikayatin ang model na gamitin ang isang 'quick workflow'. Halimbawa, maaari mong lumikha ng isang mabilis na proseso ng pagsubok na magkakasalungat upang suriin ang isang hipotesis.

Kapag gumagamit ka ng mga workflow na maaaring i-repeat, tulad ng triage, pananaliksik, o verification workflow, maaari mong i-pair ito sa /loop upang ipagpatuloy ito sa fixed interval; samantala, gamitin ang /goal para magtakda ng mga katatagan na kundisyon para sa pagkumpleto.

Maaari mong itakda ang malinaw na budget para sa paggamit ng token sa dynamic workflow upang limitahan ang bilang ng token na ginagamit ng task. Maaari mong isulat sa prompt ang tulad ng "use 10k tokens" upang itakda ang limitasyon sa 10k token.

Maaari mong pindutin ang «s» sa menu ng workflow upang i-save ang mga workflow. Maaari mong i-submit ang mga ito sa ~/.claude/workflows o i-distribute sa pamamagitan ng skill.

Kung nais mong ibahagi ang mga ito sa pamamagitan ng skill, ilagay ang JavaScript workflow file sa folder ng skill at i-referensya ito sa SKILL.md. Para sa mas malaking flexibility, maaari mo ring hilingin sa Claude: isipin ang workflows sa loob ng skill bilang mga template, hindi bilang mga iskrip na kailangang isagawa nang buong salita.

Isang buong bagong mundo

Ang workflows ay isang kapaki-pakinabang na bagong paraan upang palawakin ang Claude Code. Iminumungkahi kong ituring mo ito bilang isang simula. Mayroon pa kaming maraming matututunan tungkol sa pinakamabuting paraan ng paggamit nito. Maligayang pagdating sa pagbabahagi ng iyong mga natuklasan.

Si Thariq Shihipar at Sid Bidasaria (@sidbid) ay mga miyembro ng teknikal na tim ng Anthropic na responsable sa mga gawain kaugnay ng Claude Code.

[Original link]

Klik para malaman ang mga posisyon na hinahanap ng BlockBeats

Maligayang pagdating sa opisyal na komunidad ng BlockBeats:

Telegram subscription group: https://t.me/theblockbeats

Telegram group: https://t.me/BlockBeats_App

Twitter official account: https://twitter.com/BlockBeatsAsia