> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Perluas Fuxi Code
> Pahami kapan menggunakan FUXI.md, Skills, subagents, hooks, MCP, dan plugins.
Fuxi Code menggabungkan model yang bernalar tentang kode Anda dengan [alat bawaan](/id/how-fuxi-code-works#tools) untuk operasi file, pencarian, eksekusi, dan akses web. Alat bawaan mencakup sebagian besar tugas pengkodean. Panduan ini mencakup lapisan ekstensi: fitur yang Anda tambahkan untuk menyesuaikan apa yang Fuxi ketahui, menghubungkannya ke layanan eksternal, dan mengotomatisasi alur kerja.
Untuk cara loop agentic inti bekerja, lihat [Cara Fuxi Code Bekerja](/id/how-fuxi-code-works).
**Baru di Fuxi Code?** Mulai dengan [FUXI.md](/id/memory) untuk konvensi proyek, kemudian tambahkan ekstensi lain [saat pemicu spesifik muncul](#build-your-setup-over-time).
Ikhtisar
Ekstensi terhubung ke bagian berbeda dari loop agentic:
* **[FUXI.md](/id/memory)** menambahkan konteks persisten yang Fuxi lihat setiap sesi
* **[Skills](/id/skills)** menambahkan pengetahuan yang dapat digunakan kembali dan alur kerja yang dapat dipanggil
* **[Code intelligence](/id/tools-reference#lsp-tool-behavior)** menghubungkan Fuxi ke language server untuk navigasi tingkat simbol dan kesalahan tipe langsung
* **[MCP](/id/mcp)** menghubungkan Fuxi ke layanan dan alat eksternal
* **[Subagents](/id/sub-agents)** menjalankan loop mereka sendiri dalam konteks terisolasi, mengembalikan ringkasan
* **[Agent teams](/id/agent-teams)** mengoordinasikan beberapa sesi independen dengan tugas bersama dan pesan peer-to-peer
* **[Hooks](/id/hooks-guide)** berjalan pada acara siklus hidup dan dapat menjalankan skrip, permintaan HTTP, prompt, atau subagent
* **[Plugins](/id/plugins)** dan **[marketplaces](/id/plugin-marketplaces)** mengemas dan mendistribusikan fitur-fitur ini
[Skills](/id/skills) adalah ekstensi paling fleksibel. Skill adalah file markdown yang berisi pengetahuan, alur kerja, atau instruksi. Anda dapat memanggil skills dengan perintah seperti `/deploy`, atau Fuxi dapat memuatnya secara otomatis ketika relevan. Skills dapat berjalan dalam percakapan Anda saat ini atau dalam konteks terisolasi melalui subagents.
Cocokkan fitur dengan tujuan Anda
Fitur berkisar dari konteks yang selalu aktif yang Fuxi lihat setiap sesi, hingga kemampuan on-demand yang dapat Anda atau Fuxi panggil, hingga otomasi latar belakang yang berjalan pada acara tertentu. Tabel di bawah menunjukkan apa yang tersedia dan kapan masing-masing masuk akal.
| Fitur | Apa yang dilakukannya | Kapan menggunakannya | Contoh |
| -------------------------------------------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| **FUXI.md** | Konteks persisten dimuat setiap percakapan | Konvensi proyek, aturan "selalu lakukan X" | "Gunakan pnpm, bukan npm. Jalankan tes sebelum commit." |
| **Skill** | Instruksi, pengetahuan, dan alur kerja yang dapat digunakan Fuxi | Konten yang dapat digunakan kembali, dokumen referensi, tugas yang dapat diulang | `/deploy` menjalankan daftar periksa deployment Anda; skill dokumen API dengan pola endpoint |
| **Subagent** | Konteks eksekusi terisolasi yang mengembalikan hasil ringkasan | Isolasi konteks, tugas paralel, pekerja khusus | Tugas penelitian yang membaca banyak file tetapi hanya mengembalikan temuan kunci |
| **[Agent teams](/id/agent-teams)** | Mengoordinasikan beberapa sesi Fuxi Code independen | Penelitian paralel, pengembangan fitur baru, debugging dengan hipotesis bersaing | Spawn reviewer untuk memeriksa keamanan, performa, dan tes secara bersamaan |
| **[Code intelligence](/id/tools-reference#lsp-tool-behavior)** | Navigasi language-server dan diagnostik | Bahasa yang diketik, basis kode besar di mana grep lambat atau tidak presisi | Lompat ke definisi simbol daripada membaca seluruh file |
| **MCP** | Terhubung ke layanan eksternal | Data atau tindakan eksternal | Kueri database Anda, posting ke Slack, kontrol browser |
| **Hook** | Skrip, permintaan HTTP, prompt, atau subagent yang dipicu oleh acara | Otomasi yang harus berjalan pada setiap acara yang cocok | Jalankan ESLint setelah setiap edit file |
| **[Artifact](/id/artifacts)** | Publikasikan output sesi sebagai halaman web pribadi yang interaktif | Output yang ingin Anda lihat atau bagikan secara visual daripada sebagai teks terminal | Garis waktu insiden yang diperbarui saat Fuxi menyelidiki |
**[Plugins](/id/plugins)** adalah lapisan pengemasan. Plugin menggabungkan skills, hooks, subagents, dan MCP servers menjadi satu unit yang dapat diinstal. Plugin skills memiliki namespace (seperti `/my-plugin:review`) sehingga beberapa plugin dapat hidup berdampingan. Gunakan plugins ketika Anda ingin menggunakan kembali setup yang sama di beberapa repositori atau mendistribusikan ke orang lain melalui **[marketplace](/id/plugin-marketplaces)**.
Bangun setup Anda seiring waktu
Anda tidak perlu mengonfigurasi semuanya di awal. Setiap fitur memiliki pemicu yang dapat dikenali, dan sebagian besar tim menambahkannya dalam urutan yang kira-kira seperti ini:
| Pemicu | Tambahkan |
| :---------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------ |
| Fuxi mendapatkan konvensi atau perintah yang salah dua kali | Tambahkan ke [FUXI.md](/id/memory) |
| Anda terus mengetik prompt yang sama untuk memulai tugas | Simpan sebagai [skill](/id/skills) yang dapat dipanggil pengguna |
| Anda menempel playbook yang sama atau prosedur multi-langkah ke chat untuk ketiga kalinya | Tangkap sebagai [skill](/id/skills) |
| Anda terus menyalin data dari tab browser yang Fuxi tidak bisa lihat | Hubungkan sistem itu sebagai [server MCP](/id/mcp) |
| Fuxi membaca banyak file untuk menemukan di mana simbol didefinisikan atau digunakan | Instal [plugin code intelligence](/id/discover-plugins#code-intelligence) untuk bahasa Anda |
| Tugas sampingan membanjiri percakapan Anda dengan output yang tidak akan Anda referensikan lagi | Arahkan melalui [subagent](/id/sub-agents) |
| Anda ingin sesuatu terjadi setiap kali tanpa bertanya | Tulis [hook](/id/hooks-guide) |
| Repositori kedua membutuhkan setup yang sama | Paket sebagai [plugin](/id/plugins) |
Pemicu yang sama memberi tahu Anda kapan harus memperbarui apa yang sudah Anda miliki. Kesalahan berulang atau komentar tinjauan berulang adalah edit FUXI.md, bukan koreksi satu kali dalam chat. Alur kerja yang terus Anda sesuaikan dengan tangan adalah skill yang memerlukan revisi lain.
Bandingkan fitur serupa
Beberapa fitur dapat terlihat serupa. Berikut cara membedakannya.
Skills dan subagents menyelesaikan masalah yang berbeda:
* **Skills** adalah konten yang dapat digunakan kembali yang dapat Anda muat ke konteks apa pun
* **Subagents** adalah pekerja terisolasi yang berjalan terpisah dari percakapan utama Anda
| Aspek | Skill | Subagent |
| ----------------------------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| **Apa itu** | Instruksi, pengetahuan, atau alur kerja yang dapat digunakan kembali | Pekerja terisolasi dengan konteksnya sendiri |
| **Manfaat utama** | Bagikan konten di seluruh konteks | Isolasi konteks. Pekerjaan terjadi secara terpisah, hanya ringkasan yang kembali |
| **Dampak [context window](/id/context-window)** | Menambah jendela utama Anda | Menggunakan jendela terpisah dengan token input dan output sendiri |
| **Terbaik untuk** | Materi referensi, alur kerja yang dapat dipanggil | Tugas yang membaca banyak file, pekerjaan paralel, pekerja khusus |
**Skills dapat berupa referensi atau tindakan.** Skills referensi memberikan pengetahuan yang Fuxi gunakan sepanjang sesi Anda (seperti panduan gaya API Anda). Skills tindakan memberi tahu Fuxi untuk melakukan sesuatu yang spesifik (seperti `/deploy` yang menjalankan alur kerja deployment Anda).
**Gunakan subagent** ketika Anda membutuhkan isolasi konteks atau ketika jendela konteks Anda penuh. Subagent mungkin membaca puluhan file atau menjalankan pencarian ekstensif, tetapi percakapan utama Anda hanya menerima ringkasan. Karena pekerjaan subagent tidak mengonsumsi konteks utama Anda, ini juga berguna ketika Anda tidak memerlukan pekerjaan perantara untuk tetap terlihat. Subagents kustom dapat memiliki instruksi mereka sendiri dan dapat memuat skills sebelumnya.
**Mereka dapat digabungkan.** Subagent dapat memuat skills tertentu sebelumnya (field `skills:`). Skill dapat berjalan dalam konteks terisolasi menggunakan `context: fork`. Lihat [Skills](/id/skills) untuk detail.
Keduanya menyimpan instruksi, tetapi mereka dimuat secara berbeda dan melayani tujuan yang berbeda.
| Aspek | FUXI.md | Skill |
| --------------------------- | ---------------------------- | ------------------------------------------------- |
| **Dimuat** | Setiap sesi, secara otomatis | On demand |
| **Dapat menyertakan file** | Ya, dengan impor `@path` | Ya, dengan impor `@path` |
| **Dapat memicu alur kerja** | Tidak | Ya, dengan `/` |
| **Terbaik untuk** | Aturan "selalu lakukan X" | Materi referensi, alur kerja yang dapat dipanggil |
**Letakkan di FUXI.md** jika Fuxi harus selalu mengetahuinya: konvensi pengkodean, perintah build, struktur proyek, aturan "jangan pernah lakukan X".
**Letakkan di skill** jika itu materi referensi yang Fuxi butuhkan kadang-kadang (dokumen API, panduan gaya) atau alur kerja yang Anda picu dengan `/` (deploy, review, release).
**Aturan praktis:** Jaga FUXI.md di bawah 200 baris. Jika berkembang, pindahkan konten referensi ke skills atau pisahkan ke file [`.fuxi/rules/`](/id/memory#organize-rules-with-fuxi%2Frules%2F).
Ketiganya menyimpan instruksi, tetapi mereka dimuat secara berbeda:
| Aspek | FUXI.md | `.fuxi/rules/` | Skill |
| ----------------- | -------------------------------- | ----------------------------------------------- | ----------------------------------------------- |
| **Dimuat** | Setiap sesi | Setiap sesi, atau ketika file yang cocok dibuka | On demand, ketika dipanggil atau relevan |
| **Cakupan** | Seluruh proyek | Dapat dibatasi ke jalur file | Spesifik tugas |
| **Terbaik untuk** | Konvensi inti dan perintah build | Panduan spesifik bahasa atau direktori | Materi referensi, alur kerja yang dapat diulang |
**Gunakan FUXI.md** untuk instruksi yang setiap sesi butuhkan: perintah build, konvensi tes, arsitektur proyek.
**Gunakan rules** untuk menjaga FUXI.md tetap fokus. Rules dengan [`paths` frontmatter](/id/memory#path-specific-rules) hanya dimuat ketika Fuxi bekerja dengan file yang cocok, menghemat konteks.
**Gunakan skills** untuk konten yang Fuxi hanya butuhkan kadang-kadang, seperti dokumentasi API atau daftar periksa deployment yang Anda picu dengan `/`.
Keduanya melakukan paralelisasi pekerjaan, tetapi mereka secara arsitektur berbeda:
* **Subagents** berjalan di dalam sesi Anda dan melaporkan hasil kembali ke konteks utama Anda
* **Agent teams** adalah sesi Fuxi Code independen yang berkomunikasi satu sama lain
| Aspek | Subagent | Agent team |
| ----------------- | ------------------------------------------------------ | --------------------------------------------------------------- |
| **Konteks** | Jendela konteks sendiri; hasil kembali ke pemanggil | Jendela konteks sendiri; sepenuhnya independen |
| **Komunikasi** | Melaporkan hasil kembali ke agen utama saja | Rekan kerja saling mengirim pesan secara langsung |
| **Koordinasi** | Agen utama mengelola semua pekerjaan | Daftar tugas bersama dengan koordinasi diri |
| **Terbaik untuk** | Tugas terfokus di mana hanya hasil yang penting | Pekerjaan kompleks yang memerlukan diskusi dan kolaborasi |
| **Biaya token** | Lebih rendah: hasil diringkas kembali ke konteks utama | Lebih tinggi: setiap rekan kerja adalah instans Fuxi terpisah |
**Gunakan subagent** ketika Anda membutuhkan pekerja cepat dan terfokus: teliti pertanyaan, verifikasi klaim, tinjau file. Subagent melakukan pekerjaan dan mengembalikan ringkasan. Percakapan utama Anda tetap bersih.
**Gunakan agent team** ketika rekan kerja perlu berbagi temuan, menantang satu sama lain, dan berkoordinasi secara independen. Agent teams terbaik untuk penelitian dengan hipotesis bersaing, tinjauan kode paralel, dan pengembangan fitur baru di mana setiap rekan kerja memiliki bagian terpisah.
**Titik transisi:** Jika Anda menjalankan subagents paralel tetapi mencapai batas konteks, atau jika subagents Anda perlu berkomunikasi satu sama lain, agent teams adalah langkah alami berikutnya.
Agent teams bersifat eksperimental dan dinonaktifkan secara default. Lihat [agent teams](/id/agent-teams) untuk setup dan batasan saat ini.
MCP menghubungkan Fuxi ke layanan eksternal. Skills memperluas apa yang Fuxi ketahui, termasuk cara menggunakan layanan tersebut secara efektif.
| Aspek | MCP | Skill |
| --------------- | ------------------------------------------------ | ----------------------------------------------------------------- |
| **Apa itu** | Protokol untuk terhubung ke layanan eksternal | Pengetahuan, alur kerja, dan materi referensi |
| **Menyediakan** | Akses alat dan data | Pengetahuan, alur kerja, materi referensi |
| **Contoh** | Integrasi Slack, kueri database, kontrol browser | Daftar periksa tinjauan kode, alur kerja deploy, panduan gaya API |
Ini menyelesaikan masalah yang berbeda dan bekerja dengan baik bersama:
**MCP** memberi Fuxi alat yang dirancang khusus untuk sistem eksternal, dengan koneksi dan autentikasi ditangani oleh server.
**Skills** memberi Fuxi pengetahuan tentang cara menggunakan alat tersebut secara efektif, ditambah alur kerja yang dapat Anda picu dengan `/`. Skill mungkin menyertakan skema database tim Anda dan pola kueri, atau alur kerja `/post-to-slack` dengan aturan pemformatan pesan tim Anda.
Contoh: Server MCP menghubungkan Fuxi ke database Anda. Skill mengajarkan Fuxi model data Anda, pola kueri umum, dan tabel mana yang digunakan untuk tugas berbeda.
Hook berjalan pada acara siklus hidup; skill dimuat ke dalam konteks untuk Fuxi terapkan.
| Aspek | Hook | Skill |
| ----------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| **Berjalan** | Perintah shell, permintaan HTTP, prompt LLM, atau subagent | Instruksi yang Fuxi baca dan ikuti |
| **Dipicu oleh** | [Acara siklus hidup](/id/hooks#hook-events) seperti `PostToolUse` atau `SessionStart` | Anda mengetik `/`, atau Fuxi mencocokkan deskripsi dengan tugas Anda |
| **Determinisme** | Selalu berjalan pada acaranya; pemicu dijamin | Fuxi menginterpretasikan instruksi; hasil dapat bervariasi |
| **Biaya konteks** | Nol kecuali hook mengembalikan output | Deskripsi dimuat setiap sesi; konten penuh dimuat saat digunakan |
| **Terbaik untuk** | Linting setelah edit, memblokir perintah yang tidak aman, logging, notifikasi | Alur kerja yang memerlukan penalaran, materi referensi, tugas multi-langkah |
**Gunakan hook** ketika tindakan harus terjadi dengan cara yang sama setiap kali dan tidak perlu Fuxi berpikir. Misalnya: format saat simpan, tolak `rm -rf /`, posting pesan Slack ketika sesi berakhir.
**Gunakan skill** ketika Fuxi harus memutuskan cara menerapkan langkah-langkahnya, atau ketika kontennya adalah pengetahuan daripada skrip. Misalnya: daftar periksa `/release`, panduan gaya API Anda, playbook debugging.
**Letakkan guardrails di hooks.** Instruksi seperti "jangan pernah edit `.env`" di FUXI.md atau skill adalah permintaan, bukan jaminan. Hook `PreToolUse` yang memblokir edit adalah penegakan. Jika aturan harus berlaku setiap kali, buat hook daripada instruksi prompt.
**Output hook mendarat di konteks.** Hook `PostToolUse` yang menjalankan linter Anda memberi umpan balik hasil sebagai teks yang Fuxi baca; skill `/fix-lint` memberi tahu Fuxi cara menyelesaikannya.
Pahami bagaimana fitur berlapis
Fitur dapat didefinisikan di beberapa tingkat: seluruh pengguna, per-proyek, melalui plugins, atau melalui kebijakan terkelola. Anda juga dapat menyarangkan file FUXI.md di subdirektori atau menempatkan skills di paket tertentu dari monorepo. Ketika fitur yang sama ada di beberapa tingkat, berikut cara mereka berlapis:
* **File FUXI.md** bersifat aditif: semua tingkat berkontribusi konten ke konteks Fuxi secara bersamaan. File dari direktori kerja Anda dan di atas dimuat saat peluncuran; subdirektori dimuat saat Anda bekerja di dalamnya. Ketika instruksi bertentangan, Fuxi menggunakan penilaian untuk merekonsiliasi mereka, dengan instruksi yang lebih spesifik biasanya mengambil alih. Lihat [bagaimana file FUXI.md dimuat](/id/memory#how-fuxi-md-files-load).
* **Skills dan subagents** menimpa berdasarkan nama: ketika nama yang sama ada di beberapa tingkat, satu definisi menang berdasarkan prioritas (terkelola > pengguna > proyek untuk skills; terkelola > bendera CLI > proyek > pengguna > plugin untuk subagents). Plugin skills adalah [namespaced](/id/plugins#add-skills-to-your-plugin) untuk menghindari konflik. Lihat [penemuan skill](/id/skills#where-skills-live) dan [cakupan subagent](/id/sub-agents#choose-the-subagent-scope).
* **Server MCP** menimpa berdasarkan nama: lokal > proyek > pengguna. Lihat [cakupan MCP](/id/mcp#scope-hierarchy-and-precedence).
* **Hooks** bergabung: semua hook terdaftar berjalan untuk acara pencocokan mereka terlepas dari sumber. Lihat [hooks](/id/hooks-guide).
Gabungkan fitur
Setiap ekstensi menyelesaikan masalah yang berbeda: FUXI.md menangani konteks yang selalu aktif, skills menangani pengetahuan dan alur kerja on-demand, MCP menangani koneksi eksternal, subagents menangani isolasi, dan hooks menangani otomasi. Setup nyata menggabungkan mereka berdasarkan alur kerja Anda.
Misalnya, Anda mungkin menggunakan FUXI.md untuk konvensi proyek, skill untuk alur kerja deployment Anda, MCP untuk terhubung ke database Anda, dan hook untuk menjalankan linting setelah setiap edit. Setiap fitur menangani apa yang terbaik.
| Pola | Cara kerjanya | Contoh |
| ---------------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| **Skill + MCP** | MCP menyediakan koneksi; skill mengajarkan Fuxi cara menggunakannya dengan baik | MCP terhubung ke database Anda, skill mendokumentasikan skema dan pola kueri Anda |
| **Skill + Subagent** | Skill menspawn subagents untuk pekerjaan paralel | Skill `/audit` memulai subagents keamanan, performa, dan gaya yang bekerja dalam konteks terisolasi |
| **FUXI.md + Skills** | FUXI.md menyimpan aturan yang selalu aktif; skills menyimpan materi referensi yang dimuat on-demand | FUXI.md mengatakan "ikuti konvensi API kami," skill berisi panduan gaya API lengkap |
| **Hook + MCP** | Hook memicu tindakan eksternal melalui MCP | Hook pasca-edit mengirim notifikasi Slack ketika Fuxi memodifikasi file kritis |
Pahami biaya konteks
Setiap fitur yang Anda tambahkan mengonsumsi beberapa konteks Fuxi. Terlalu banyak dapat mengisi jendela konteks Anda, tetapi juga dapat menambah kebisingan yang membuat Fuxi kurang efektif; skills mungkin tidak dipicu dengan benar, atau Fuxi mungkin kehilangan jejak konvensi Anda. Memahami trade-off ini membantu Anda membangun setup yang efektif. Untuk tampilan interaktif tentang bagaimana fitur-fitur ini bergabung dalam sesi yang berjalan, lihat [Jelajahi context window](/id/context-window).
Biaya konteks berdasarkan fitur
Setiap fitur memiliki strategi pemuatan dan biaya konteks yang berbeda:
| Fitur | Kapan dimuat | Apa yang dimuat | Biaya konteks |
| --------------------- | ------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------ |
| **FUXI.md** | Awal sesi | Konten penuh | Setiap permintaan |
| **Skills** | Awal sesi + ketika digunakan | Deskripsi di awal, konten penuh ketika digunakan | Rendah (deskripsi setiap permintaan)\* |
| **Server MCP** | Awal sesi | Nama alat; skema penuh on demand | Rendah sampai alat digunakan |
| **Code intelligence** | Setelah pengeditan file dan on demand | Diagnostik setelah pengeditan; lokasi simbol saat pencarian | Rendah; mengurangi pembacaan file di tempat lain |
| **Subagents** | Ketika dispawn | Konteks segar dengan skills yang ditentukan | Terisolasi dari sesi utama |
| **Hooks** | Saat dipicu | Tidak ada (berjalan secara eksternal) | Nol, kecuali hook mengembalikan konteks tambahan |
\*Secara default, deskripsi skill dimuat saat awal sesi sehingga Fuxi dapat memutuskan kapan menggunakannya. Atur `disable-model-invocation: true` di frontmatter skill untuk menyembunyikannya dari Fuxi sepenuhnya sampai Anda memanggilnya secara manual. Ini mengurangi biaya konteks menjadi nol untuk skills yang hanya Anda picu sendiri. Untuk skill yang tidak Anda tulis, atur [`skillOverrides`](/id/skills#override-skill-visibility-from-settings) di settings untuk melakukan hal yang sama tanpa mengedit filenya.
Pahami bagaimana fitur dimuat
Setiap fitur dimuat pada titik berbeda dalam sesi Anda. Tab di bawah menjelaskan kapan masing-masing dimuat dan apa yang masuk ke konteks.
**Kapan:** Awal sesi
**Apa yang dimuat:** Konten penuh semua file FUXI.md (tingkat terkelola, pengguna, dan proyek).
**Warisan:** Fuxi membaca file FUXI.md dari direktori kerja Anda hingga ke root, dan menemukan yang tersarang di subdirektori saat mengakses file tersebut. Lihat [Bagaimana file FUXI.md dimuat](/id/memory#how-fuxi-md-files-load) untuk detail.
Jaga FUXI.md di bawah 200 baris. Pindahkan materi referensi ke skills, yang dimuat on-demand.
Skills adalah kemampuan tambahan dalam toolkit Fuxi. Mereka dapat berupa materi referensi (seperti panduan gaya API) atau alur kerja yang dapat dipanggil yang Anda picu dengan `/` (seperti `/deploy`). Fuxi Code dilengkapi dengan [skills bundel](/id/commands) seperti `/code-review`, `/batch`, dan `/debug` yang bekerja langsung. Anda juga dapat membuat yang Anda sendiri. Fuxi menggunakan skills ketika sesuai, atau Anda dapat memanggil satu secara langsung.
**Kapan:** Tergantung pada konfigurasi skill. Secara default, deskripsi dimuat saat awal sesi dan konten penuh dimuat ketika digunakan. Untuk skills hanya pengguna (`disable-model-invocation: true`), tidak ada yang dimuat sampai Anda memanggilnya.
**Apa yang dimuat:** Untuk skills yang dapat dipanggil model, Fuxi melihat nama dan deskripsi di setiap permintaan. Ketika Anda memanggil skill dengan `/` atau Fuxi memuatnya secara otomatis, konten penuh dimuat ke percakapan Anda.
**Bagaimana Fuxi memilih skills:** Fuxi mencocokkan tugas Anda terhadap deskripsi skill untuk memutuskan mana yang relevan. Jika deskripsi samar atau tumpang tindih, Fuxi mungkin memuat skill yang salah atau melewatkan yang akan membantu. Untuk memberi tahu Fuxi menggunakan skill tertentu, panggilnya dengan `/`. Skills dengan `disable-model-invocation: true` tidak terlihat oleh Fuxi sampai Anda memanggilnya.
**Biaya konteks:** Rendah sampai digunakan. Skills hanya pengguna memiliki biaya nol sampai dipanggil.
**Di subagents:** Skills bekerja berbeda di subagents. Alih-alih pemuatan on-demand, skills yang tercantum di field `skills:` subagent sepenuhnya dimuat sebelumnya ke konteksnya saat peluncuran. Subagents masih dapat menemukan dan memanggil skills proyek, pengguna, dan plugin yang tidak tercantum melalui alat Skill.
Gunakan `disable-model-invocation: true` untuk skills dengan efek samping. Ini menghemat konteks dan memastikan hanya Anda yang memicunya.
**Kapan:** Awal sesi.
**Apa yang dimuat:** Nama alat dari server yang terhubung. Skema JSON penuh tetap ditunda sampai Fuxi memerlukan alat tertentu.
**Biaya konteks:** [Pencarian alat](/id/mcp#scale-with-mcp-tool-search) diaktifkan secara default, jadi alat MCP idle mengonsumsi konteks minimal.
Jalankan `/mcp` untuk melihat status koneksi dan biaya token per server. Fuxi Code [terhubung kembali ke server jarak jauh secara otomatis](/id/mcp#automatic-reconnection) jika mereka terputus, dan Anda dapat memutuskan server yang tidak Anda gunakan secara aktif.
**Kapan:** Setelah pengeditan file, dan on demand ketika Fuxi menavigasi kode.
**Apa yang dimuat:** Kesalahan tipe dan peringatan setelah setiap pengeditan file. Informasi definisi, referensi, dan tipe ketika Fuxi mencari simbol.
**Biaya konteks:** Rendah. Pencarian simbol sering menggantikan pembacaan file yang luas, jadi penggunaan konteks bersih dapat turun.
Alat LSP tidak aktif sampai Anda memasang [plugin code intelligence](/id/discover-plugins#code-intelligence) untuk bahasa Anda.
**Kapan:** On demand, ketika Anda atau Fuxi menspawn satu untuk tugas.
**Apa yang dimuat:** Konteks segar dan terisolasi yang berisi:
* Prompt sistem agen, bukan prompt sistem Fuxi Code lengkap
* Konten penuh skills yang tercantum di field `skills:` agen
* FUXI.md dan status git, kecuali agen Explore dan Plan bawaan [menghilangkan keduanya](/id/sub-agents#what-loads-at-startup)
* Apa pun konteks yang agen utama lewatkan dalam prompt
**Biaya konteks:** Terisolasi dari sesi utama. Subagents tidak mewarisi riwayat percakapan Anda atau skills yang dipanggil.
Gunakan subagents untuk pekerjaan yang tidak memerlukan konteks percakapan penuh Anda. Isolasi mereka mencegah mengembang sesi utama Anda.
**Kapan:** Saat dipicu. Hooks berjalan pada acara siklus hidup tertentu seperti eksekusi alat, batas sesi, pengajuan prompt, permintaan izin, dan pemadatan. Lihat [Hooks](/id/hooks) untuk daftar lengkap.
**Apa yang dimuat:** Tidak ada secara default. Hooks berjalan di luar percakapan utama.
**Biaya konteks:** Nol, kecuali hook mengembalikan output yang ditambahkan sebagai pesan ke percakapan Anda.
Hooks ideal untuk efek samping (linting, logging) yang tidak perlu mempengaruhi konteks Fuxi.
Pelajari lebih lanjut
Setiap fitur memiliki panduan sendiri dengan instruksi setup, contoh, dan opsi konfigurasi.
Simpan konteks proyek, konvensi, dan instruksi
Berikan Fuxi keahlian domain dan alur kerja yang dapat digunakan kembali
Alihkan pekerjaan ke konteks terisolasi
Koordinasikan beberapa sesi yang bekerja secara paralel
Hubungkan Fuxi ke layanan eksternal
Otomatisasi alur kerja dengan hooks
Bundel dan bagikan set fitur
Host dan distribusikan koleksi plugin