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 isang parehong kontekstong window na “isipin muna, tapos gawin,” kundi maaari itong magbuo nang dinamiko ng isang framework para sa pagpapatupad: paghahati ng mga gawain, pagkakaloob ng mga sub-Agent, pagpapatakbo nang sabay-sabay, pagpapatotoo ng krus, pag-uulit sa loop, at kahit pagpapagana ng pagkakalaban sa pagitan ng iba’t ibang Agent, bago ang mga resulta ay isasama.

Ibig sabihin nito, ang mga paggamit ng Claude Code ay nagkakaroon ng malaking epekto. Hindi ito limitado sa paglipat ng code, pag-restructure, pag-uulit 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, pagpapalalim ng mga patakaran, pagrereview ng business plan, at pag-brainstorm ng mga pangalan, at iba pang non-technical na gawain. 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 mga iba’t ibang posibleng landas.

Sinusubaybayan ng dynamic workflows ang ilang karaniwang problema sa mga malalaking modelo sa mahabang gawain: ang "agent laziness" na nagpapahayag ng pagkumpleto habang nasa gitna pa lamang, ang "self-bias" na may tendensya na tanggapin ang sariling konklusyon, at ang "goal drift" na unti-unting umalis sa orihinal na layunin pagkatapos ng maraming pagpapatakbo. 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 naglalabas ito ng higit pang token at hindi laging angkop para sa bawat pangkaraniwang coding task. Ngunit binibigay nito ang isang mahalagang direksyon: ang kompetisyon sa mga hinaharap na AI tool ay maaaring hindi lamang batay sa kung gaano katalino ang isang modelo, kundi kung kaya nito ang pag-organisa ng isang mapagkakatiwalaan, maaaring muli gamitin, at maaaring i-audit na proseso sa paligid ng mga kumplikadong layunin.

Narito ang orihinal na teksto:

Bagaman ang default na execution framework ng Claude Code ay ginawa para sa programming, maaari itong gamitin din sa maraming iba pang uri ng mga gawain. Napatunayan na maraming gawain ay may katulad na istruktura sa mga gawain sa programming. Gayunpaman, upang makamit ang pinakamahusay na pagganap sa ilang partikular na uri ng gawain, kailangan pa rin nating bumuo ng mga custom na execution framework sa ibabaw ng Claude Code, tulad ng pananaliksik, pagsusuri sa kaligtasan, 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 nabanggit, pati na rin ang iba pang uri ng mga problema. Maaari mo ring ibahagi at gamitin muli ang mga workflow na ito kasama ang iba.

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

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

Tanda: Ang artikulong ito ay ipinapahayag din 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:

Nagkakaroon ng pagkabigo sa bawat 50 pagpapatakbo ng pagsubok. Lumikha ng workflow upang muling ipakita ito, magbigay ng isang hipotesis, at isagawa ang adversarial testing sa iba’t ibang worktree. /goal Huwag magpahinga hanggang sa matotohanan ang isang hipotesis.

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

Gamitin ang 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 hayaan ang iba’t ibang agent na i-decompose ito mula sa pananaw ng investor, customer, at kalaban.

May isang folder na naglalaman ng 80 na resume. Gamitin ang workflow upang ayusin ang mga ito 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 CLI tool na ito. Gamitin ang workflow upang mag-brainstorm ng isang listahan ng mga opsyon, at 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 patunayan ang bawat teknikal na pagpapasya sa codebase. Ayaw kong i-publish 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 napapansin na ang dinamikong workflow ay maaaring matukoy kung anong model ang gagamitin ng isang agent, at kung ang mga sub-agent ay magpapatakbo sa kanilang sariling worktree. Ito ay nagpapahintulot sa Claude na awtomatikong pumili ng kinakailangang antas ng inteligensya at antas ng pagkakahiwalay 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 gampanan ang isang gawain, kailangan nito na magplano at magexecute nang sabay-sabay sa loob ng iisang context window. Para sa maraming programming tasks, sobrang epektibo ang paraang ito, ngunit minsan ay nababigo ito sa mahabang panahon, malawakang paralelo, o mataas na istrakturadong pakikidigma.

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

Ang agentic laziness (inteligenteng kawalan ng paggawa) ay tumutukoy sa pagkakaroon ng Claude na huminto bago matapos ang isang napakakomplikadong gawain na may maraming bahagi, at sinasabing natapos na ito kahit na nakuha lang ang bahagyang progreso. Halimbawa, sa isang pagsusuri sa kaligtasan, nagtrabaho lang sa 20 sa 50 mga proyekto at sinasabing natapos na ang trabaho.

Self-preferential bias (self-preferential bias) ay tumutukoy sa pagkakaroon ng pagpapahalaga ni Claude sa kanyang sariling mga resulta o natuklasan, lalo na kapag hinihingi na patunayan o husgahan ang kanyang mga output batay sa isang set ng mga pamantayan.

Ang goal drift (pagkawala ng layunin) ay tumutukoy sa pagbaba 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; maaaring mawala ang ilang detalye tulad ng mga edge case o mga limitasyon tulad ng "hindi gawin ang X".

Ang paggawa ng workflow ay nakakatulong na malutas ang mga problema na ito, dahil ito ay nakakapag-ayos ng maraming hiwalay na Claude, na may sariling window ng konteksto at nakafokus sa mga layuning malinaw at isinasaayos sa isa't isa.

Maaari mo nang ginawa ang mga static workflow para sa pag-coordinate sa maraming Claude Code instances gamit ang Claude Agent SDK o claude -p.

Ngunit dahil kailangan ng static workflows na sakop ang iba't ibang edge cases, karaniwang mas pangkalahatan sila. Kasama na ang Claude Opus 4.8 at dynamic workflows, sapat na ang inteligensya ni 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 direktang hilingin 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 mong i-guide ang Claude sa pamamagitan ng prompt.

Ginagamit ni Claude ang mga sumusunod na pattern at pinag-uugnay nito sa pagbuo ng workflows:

I-classify at atexecute: 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.

Pagpapalawig at pagsasama: Ihiwalay ang isang gawain sa maraming mas maliit na hakbang, kung saan bawat hakbang ay pinapagana ng isang agent, at pagkatapos ay isasama ang mga resulta. Ang paraang ito ay partikular na epektibo para sa mga gawain na naglalaman ng maraming maliit na hakbang, o kung kailangan ng bawat hakbang ng malinaw na kontekstong window upang maiwasan ang pagkakainggitan o pagkakasalungat. Ang proseso ng pagsasama ay katulad ng isang “barrier”: ito ay maghihintay hanggang sa matapos lahat ng mga agent na pinagpalawig, at pagkatapos ay sasamahin ang kanilang structured output sa isang resulta.

Adversarial validation: Para sa bawat nabuong agent, patakbuhin ang isang hiwalay na agent upang masuri ang output nito ayon sa isang takdang pamantayan o kriteryo.

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

Torneo: Huwag hatiin ang trabaho, kundi hayaang makipagkumpitensya ang mga agent. Gumawa ng N mga agent at hayaan silang subukan ang parehong gawain gamit ang iba’t ibang paraan. Pagkatapos, gamitin ang prompt o modelo upang suriin at ihambing ang mga resulta ng mga agent nang pares-pares hanggang makamit ang tagumpay.

Ulitin hanggang makumpleto: Para sa mga gawain na hindi alam ang dami, huwag magtakda ng fixed na bilang ng round; kundi ulitin ang pagbuo ng agent hanggang matugunan ang kondisyon para sa paghinto, tulad ng pagkakaroon ng wala nang mga bagong natuklasan o pagkakaroon ng wala nang mga error sa log.

Gamit na sitwasyon

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

Gamit ni Bun ang workflows para i-rewrite mula sa Zig patungo 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 task sa worktree upang matapos nito ang pagkakabawas; pagkatapos ay hayaan ang isa pang agent na magbigay ng kontrabida na pagsusuri, at huli ay i-merge ang mga resulta. Maaari mong ipaalam nang malinaw sa agent na huwag gamitin ang mga utos na naglalabas ng maraming yaman, upang maksimisahin ang pagkakaparalelo nang hindi mabawasan ang mga lokal na yaman ng machine.

Isinampa namin ang isang deep research skill (/deep-research) sa Claude Code, na gumagamit ng dynamic workflow. Sa partikular, ito ay magpapalabas ng mga webpage search, i-crawl ang mga pinagkukunan, magpapatupad ng adversarial verification sa mga kaugnay na klaim, at mag-iisip ng isang komprehensibong ulat na may mga sanggunian.

Ngunit hindi lamang ito nakatutulong sa paghahanap sa web. Halimbawa, maaari mo ring hilingin sa Claude na magbuo ng isang status report mula sa konteksto ng Slack, o pagsuriin ang isang codebase upang maunawaan kung paano gumagana ang isang partikular na feature.

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 pag-verify. Maaari mo ring bigyan ng papel ang isang verification agent upang suriin ang 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 indikador. Halimbawa, ayusin ang mga support ticket batay sa kalubusan ng mga bug.

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

Kung mayroon kang isang set ng partikular na patakaran, at ang Claude ay madalas na nagkakamali o hindi nagpapatupad nang maayos kahit na nakikita nito ang mga patakaran sa CLAUDE.md, maaari mong lumikha ng isang workflow na listahan ang mga patakaran at ipagkaloob sa bawat verification agent ang pag-check sa bawat patakaran—bawat patakaran ay may sariling verification agent. Ang paglikha ng isang sub-agent na may personality na “skeptik” 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 sa iyong nakaraang 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 ito upang matukoy kung talagang maiiwasan nito ang isang totoong error; 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 hiwalay na hipotesis at pagsubok sa bawat isa. Ngunit kung gagamitin mo lamang ang isang context window, maaaring mabigo si Claude sa sariling bias.

Ang workflow ay maaaring pigilan ang ganitong sitwasyon sa pamamagitan ng istruktura: maaari itong mag-start ng maraming agent upang sila ay magbuo ng mga hipotesis batay sa mga ebidensya na hindi nagkakasalungatan. 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 magpapaliwanag.

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 suportang queue, bug report, o iba pang backlog na hindi maaaring lubos na penanagutan ng tao. Ang isang triage workflow ay maaaring magkategorya sa bawat item, mag-remove ng duplicate sa mga problema 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 action ng mga agent na bumabasa ng hindi kapani-paniwala publikong nilalaman; ang mga high-privilege action ay dapat gawin ng mga espesyal na agent na responsable sa aksyon.

Maaari mong gamitin ang triage workflows kasama ang /loop upang pahintulutan ang Claude na patuloy na isagawa ang mga gawain na ito.

Kapag kailangan mong masuri 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, ang workflows ay kapaki-pakinabang.

Maaari mong pahintulutan ang Claude na mag-explor ng maraming solusyon at ibigay sa审查 agent ang isang set ng mga pamantayan kung ano ang "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 tournament mechanism.

Maaari mong pagsimulan ang isang lightweight eval para sa isang partikular na gawain sa pamamagitan ng pagpapalawak ng isang independent agent sa worktree, pagkatapos ay pagsimulan ang comparative agent upang ihambing at iskor ang output batay sa mga pamantayan. Halimbawa, maaari mong isagawa ang pag-evaluate at pagpapabuti sa isang skill na iyong nilikha upang makita kung ito ay sumasapat sa mga partikular na pamantayan.

Model at Intelligent Level Routing: Maaari mong lumikha ng isang classification agent na na-optimize para sa iyong task, na magpapasya kung aling model ang gagamitin. Kapag ang task ay nagsasangkot ng maraming pagtawag sa mga tool, at ang pag-aaral bago ang pagsasagawa ay makakatulong upang matukoy ang pinakamabisang model, ang paraang ito ay lubos na kapaki-pakinabang.

Halimbawa, para sa gawain na “Ipaliwanag kung paano gumagana ang auth module”, ang pinakamabisang model ay depende sa bilang ng mga file sa auth module at sa istruktura ng codebase. Ang classification agent ay maaaring unang gawin ang pag-aaral, 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 palakasin ang pagkawala ng token.

Gamitin ang workflows sa mga gawain na maaaring palawakin ang hangganan ng kakayahan ni Claude Code sa mga bagong paraan. Para sa karaniwang mga gawain sa pagprograma, tanungin muna ang sarili mo: Kailangan ba talaga ng gawain na ito ng mas maraming compute resources? Halimbawa, hindi kailangan ng karamihan sa mga tradisyonal na gawain sa pagprograma ng isang grupo ng 5 na reviewer.

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 workflows ang nagagamit para sa malalaking gawain. Maaari mo ring hingin sa modelo na gamitin ang isang 'quick workflow'. Halimbawa, maaari mong lumikha ng isang mabilis na proseso ng pagsubok na kontrabida 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 ang mga ito sa /loop upang ipagana ang mga ito sa regular na interval; samantala, gamitin ang /goal para magtakda ng mga tiyak na kriteryo 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 ang tulad ng "use 10k tokens" sa prompt, at ito ay magtatakdang 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 ibahagi sa pamamagitan ng skill.

Kung nais mong i-share 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 i-run nang letra-dakila.

Isang buong bagong mundo

Ang workflows ay isang kapaki-pakinabang na bagong paraan upang palawigin ang Claude Code. Iminumungkahi kong ituring mo ito bilang isang simula. Mayroon pa kaming maraming dapat pag-aralan tungkol sa paano gamitin ito nang pinakamahusay. 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.