Bapak Claude Code Membongkar Rahasia: Bagaimana Mengubah Claude Menjadi "Tim Pengembangan Virtual" Anda?

marsbit发布于2026-01-05更新于2026-01-05

文章摘要

Artikel ini merangkum pengalaman Boris Cherny, pengembang Claude Code, dalam menggunakan Claude sebagai "tim pengembangan virtual". Boris menekankan penggunaan Claude bukan sekadar alat, tetapi mitra kolaboratif yang terus belajar. Kunci strateginya meliputi: - Menggunakan model Opus 4.5 untuk pemahaman lebih baik - Mode Perencanaan (Plan Mode) untuk menyelaraskan tujuan sebelum menulis kode - Menjalankan banyak sesi Claude secara paralel untuk berbagai tugas - Membuat perintah slash (slash commands) untuk mengotomatiskan alur kerja berulang - Membangun basis pengetahuan tim yang terus diperbarui - Mekanisme pembelajaran otomatis melalui review PR - Subagen untuk menangani tugas-tugas khusus - Hook pasca-penggunaan alat untuk pemformatan kode - Manajemen izin yang aman dengan daftar putih perintah - Integrasi dengan alat lain melalui MCP - Mekanisme verifikasi otomatis untuk memastikan keakuratan output Pendekatan ini mengubah Claude dari asisten percakapan menjadi sistem pemrograman otomatis yang andal, meningkatkan efisiensi melalui kolaborasi terstruktur dan umpan balik terotomatisasi.

Penulis Asli: Boris Cherny, Pengembang Claude Code

Kompilasi & Penyuntingan: Xiaohu AI

Anda mungkin pernah mendengar tentang Claude Code, atau bahkan menggunakannya untuk menulis kode atau mengedit dokumen. Tapi pernahkah Anda berpikir: jika AI bukan sekadar "alat sementara", tetapi anggota resmi dalam alur kerja pengembangan Anda, bahkan sebuah sistem kolaborasi otomatis—bagaimana cara kerjanya akan mengubah cara Anda bekerja?

Sebagai Bapak Claude Code, Boris Cherny menulis sebuah utas Twitter yang sangat detail, berbagi pengalamannya menggunakan alat ini secara efisien, dan bagaimana dia serta timnya mengintegrasikan Claude secara mendalam ke dalam seluruh proses rekayasa saat bekerja.

Artikel ini akan menyusun dan menafsirkan pengalamannya secara sistematis dan mudah dipahami.

Bagaimana Boris membuat AI menjadi mitra otomatisasi dalam alur kerjanya?

Poin Inti:

Dia memperkenalkan alur kerjanya, termasuk:

Bagaimana menggunakan Claude:

Menjalankan banyak Claude sekaligus: Membuka 5~10 sesi di terminal dan web untuk menangani tugas secara paralel, juga menggunakan Claude di ponsel.

Tidak mengubah setelan default: Claude dapat langsung digunakan (out-of-the-box), tidak perlu konfigurasi rumit.

Menggunakan model terkuat (Opus 4.5): Meskipun sedikit lebih lambat, tetapi lebih pintar, dan lebih mudah digunakan.

Merencanakan sebelum menulis kode (Mode Rencana): Minta Claude membantu Anda memikirkan dengan jelas sebelum menulis, tingkat keberhasilannya tinggi.

Setelah menghasilkan kode, periksa formatnya dengan alat untuk menghindari kesalahan.

Bagaimana membuat Claude semakin pintar:

Tim memelihara sebuah "basis pengetahuan": Setiap kali Claude menulis sesuatu yang salah, tambahkan pengalaman ke dalamnya, lain kali tidak akan mengulangi kesalahan yang sama.

Melatih Claude secara otomatis saat menulis PR: Biarkan Claude melihat PR, mempelajari penggunaan atau standar baru.

Mengubah perintah yang sering digunakan sendiri menjadi perintah slash, Claude dapat memanggilnya secara otomatis, menghemat pekerjaan berulang.

Menggunakan "sub-agen" untuk menangani beberapa tugas tetap, seperti penyederhanaan kode, verifikasi fungsi, dll.

Bagaimana mengelola izin:

Tidak melewati izin secara sembarangan, tetapi mengatur perintah aman yang disetujui otomatis.

Sinkronisasi alur kerja Claude di banyak perangkat (web, terminal, ponsel).

Poin terpenting:

Pastikan untuk memberikan Claude "mekanisme verifikasi", sehingga dapat memastikan apakah yang ditulisnya benar atau tidak.

Misalnya, Claude secara otomatis menjalankan pengujian, membuka browser untuk menguji halaman web, memeriksa apakah fungsi berhasil.

Claude Code adalah "Rekan", Bukan "Alat"

Pertama-tama, Boris menyampaikan konsep inti: Claude Code bukanlah alat statis, melainkan mitra cerdas yang dapat bekerja sama dengan Anda, terus belajar, dan berkembang bersama.

Claude tidak memerlukan banyak konfigurasi rumit, langsung kuat saat digunakan. Tetapi jika Anda bersedia meluangkan waktu untuk membangun cara penggunaan yang lebih baik, peningkatan efisiensi yang dibawanya bisa berlipat ganda.

Pemilihan Model: Pilih yang Paling Pintar, Bukan yang Tercepat

Boris menggunakan model unggulan Claude, Opus 4.5 + mode pemikiran ("with thinking") untuk semua tugas pengembangan.

Meskipun model ini lebih besar dan lebih lambat daripada Sonnet, tetapi:

  • Kemampuan pemahamannya lebih kuat
  • Kemampuan menggunakan alat lebih baik
  • Tidak perlu berulang kali dibimbing, mengurangi komunikasi bolak-balik
  • Secara keseluruhan, lebih menghemat waktu daripada menggunakan model cepat
  • Pencerahan: Produktivitas sebenarnya tidak terletak pada kecepatan eksekusi, tetapi pada "sedikit kesalahan, sedikit pekerjaan ulang, sedikit penjelasan berulang".

1. Mode Rencana: Saat menggunakan AI untuk menulis kode, jangan buru-buru menyuruhnya "menulis"

Saat kita membuka Claude, banyak orang secara intuitif memasukkan "bantu saya menulis antarmuka", "refaktor kode ini"... Claude biasanya juga akan "menulis sesuatu", tetapi seringkali menyimpang, melewatkan logika, bahkan salah memahami kebutuhan.

Sedangkan langkah pertama Boris tidak pernah menyuruh Claude menulis kode. Dia menggunakan Mode Rencana — pertama-tama membuat rencana implementasi bersama Claude, baru kemudian masuk ke tahap eksekusi.

Bagaimana dia melakukannya?

Saat memulai sebuah PR, Boris tidak langsung menyuruh Claude menulis kode, tetapi menggunakan Mode Rencana:

1. Jelaskan tujuan

2. Buat rencana bersama Claude

3. Konfirmasi setiap langkah

4. Baru suruh Claude menulis

Setiap kali perlu mengimplementasikan fungsi baru, seperti "menambahkan pembatasan laju (rate limiting) untuk某个 API", dia akan mengonfirmasi langkah demi langkah dengan Claude:

  • Apakah diimplementasikan dengan middleware, atau disematkan dalam logika?
  • Apakah konfigurasi pembatasan laju perlu mendukung modifikasi dinamis?
  • Apakah perlu log? Apa yang dikembalikan saat gagal?

Proses "negosiasi rencana" ini mirip dengan dua orang yang bersama-sama "gambar rencana konstruksi".

Setelah Claude memahami tujuan dengan jelas, Boris akan membuka mode "edit diterima otomatis", Claude dapat langsung memodifikasi kode, mengirimkan PR, terkadang bahkan tidak perlu konfirmasi manual lagi.

"Kualitas kode Claude tergantung pada apakah Anda telah mencapai kesepakatan sebelum menulis kode." — Boris

Pencerahan: Daripada terus-menerus memperbaiki kesalahan Claude, lebih baik dari awal bersama-sama membuat peta rute yang jelas.

Ringkasan

Mode Rencana bukan membuang waktu, tetapi menggunakan negosiasi di depan untuk pertukaran eksekusi yang stabil. AI sekuat apa pun, tetap perlu "Anda jelaskan dengan jelas".

2. Paralel Multi-Claude: Bukan Satu AI, Melainkan Satu Tim Pengembangan Virtual

Boris tidak hanya menggunakan satu Claude. Kesehariannya seperti ini:

  • Membuka 5 Claude lokal di terminal, sesi dialokasikan untuk tugas yang berbeda (misalnya refaktor, menulis tes, debug bug)
  • Membuka 5–10 Claude lagi di browser, berjalan paralel dengan lokal
  • Menggunakan aplikasi Claude iOS di ponsel, memulai tugas kapan saja

Setiap instance Claude, seperti sebuah "asisten khusus": ada yang bertugas menulis kode, ada yang melengkapi dokumen, ada yang berjalan lama di latar belakang menjalankan tugas pengujian.

Dia bahkan mengatur notifikasi sistem, saat Claude menunggu input, dia dapat langsung diingatkan.

Mengapa melakukan ini?

Konteks Claude bersifat lokal, tidak cocok untuk "satu jendela melakukan semua hal". Boris membagi Claude menjadi beberapa peran untuk diproses secara paralel, di satu sisi mengurangi waktu tunggu, di sisi lain mengurangi "memori gangguan".

Dia juga mengingatkan dirinya sendiri melalui notifikasi sistem: "Claude 4 sedang menunggu balasan Anda", "Claude 1 menyelesaikan pengujian", seperti mengelola sistem multi-thread untuk mengelola AI ini.

Analogi Pemahaman

Anda bisa bayangkan diri Anda dikelilingi oleh lima magang pintar, masing-masing bertanggung jawab atas satu tugas. Anda tidak perlu melakukan setiap hal sampai selesai, cukup "ganti orang" pada saat-saat kritis, menjaga tugas berjalan lancar.

Pencerahan: Menganggap Claude sebagai beberapa "asisten virtual", masing-masing menangani tugas berbeda, dapat secara signifikan mengurangi waktu tunggu dan biaya pengalihan konteks.

3. Perintah Slash: Ubah Hal yang Anda Lakukan Setiap Hari Menjadi Perintah Cepat Claude

Beberapa alur kerja, kami lakukan puluhan kali setiap hari:

  • Memodifikasi kode → commit → push → membuat PR
  • Memeriksa status build → memberi tahu tim → memperbarui issue
  • Menyinkronkan perubahan ke beberapa sesi Web dan lokal
  • Boris tidak ingin setiap kali memberi tahu Claude: "Tolong commit dulu, lalu push, lalu buat PR..."

Dia membungkus operasi ini menjadi perintah Slash, misalnya:

/commit-push-pr

Di balik perintah ini adalah logika skrip Bash, disimpan di folder .claude/commands/, ditambahkan ke manajemen Git, semua anggota tim dapat menggunakan.

Bagaimana Claude menggunakan perintah ini?

Saat Claude menemukan perintah ini, dia tidak hanya "mengeksekusi perintah", tetapi juga tahu alur kerja yang diwakili oleh perintah ini, dan dapat secara otomatis mengeksekusi langkah-langkah perantara, mengisi parameter sebelumnya, menghindari komunikasi berulang.

Poin Pemahaman

Perintah Slash seperti "tombol otomatis" yang Anda instal untuk Claude. Anda melatihnya untuk memahami alur tugas, setelah itu dapat mengeksekusi dengan satu klik.

"Bukan hanya saya yang bisa menghemat waktu dengan perintah, Claude juga bisa." — Boris

Pencerahan: Jangan setiap kali memasukkan prompt berulang, abstraksikan tugas frekuensi tinggi menjadi perintah, kerja sama Anda dan Claude baru bisa "otomatis".

4. Basis Pengetahuan Tim: Claude Belajar Bukan dari Prompt, Melainkan dari Gen Pengetahuan yang Dikelola Tim

Tim Boris memelihara sebuah basis pengetahuan .claude, dan ditambahkan ke manajemen Git.

Ini seperti "Wikipedia internal" untuk Claude, mencatat:

  • Penulisan apa yang benar
  • Apa praktik terbaik yang disepakati tim
  • Saat menghadapi masalah tertentu, bagaimana cara memperbaikinya

Claude akan secara otomatis merujuk basis pengetahuan ini untuk memahami konteks, menilai gaya kode.

Saat Claude melakukan kesalahan, apa yang harus dilakukan?

Setiap kali Claude muncul kesalahpahaman atau menulis logika yang salah, tambahkan pelajaran ke dalamnya.

Setiap tim memelihara versinya sendiri.

Semua orang mengedit secara kolaboratif, Claude akan secara real-time merujuk basis pengetahuan ini untuk membuat penilaian.

Contoh:

Jika Claude selalu salah menulis logika paginasi, tim hanya perlu menulis standar paginasi yang benar ke dalam basis pengetahuan, setiap pengguna berikutnya dapat secara otomatis mendapat manfaat.

Cara Boris: Tidak memarahinya, tidak mematikannya, tetapi "latih sekali":

Kode ini tidak kami tulis seperti ini, tambahkan ke basis pengetahuan

Lain kali Claude tidak akan membuat kesalahan ini lagi.

Yang lebih penting, mekanisme ini bukan dipelihara oleh Boris sendiri, tetapi seluruh tim berkontribusi dan memodifikasi setiap minggu.

Pencerahan: Menggunakan AI, bukan setiap orang berjuang sendiri, tetapi membangun sistem "memori kolektif".

5. Mekanisme Pembelajaran Otomatis: PR itu Sendiri adalah "Data Pelatihan" Claude

Saat melakukan tinjauan kode, Boris sering @Claude di PR, misalnya:

@.claude Tambahkan cara penulisan fungsi ini ke basis pengetahuan

Dengan GitHub Action, Claude akan secara otomatis mempelajari maksud di balik perubahan ini, dan memperbarui pengetahuan internal.

Ini mirip dengan "melatih Claude secara berkelanjutan", setiap peninjauan tidak hanya menggabungkan kode, tetapi juga meningkatkan kemampuan AI.

Ini bukan lagi "pemeliharaan akhir", tetapi mengintegrasikan mekanisme pembelajaran AI ke dalam kolaborasi sehari-hari.

Tim menggunakan PR untuk meningkatkan kualitas kode, Claude secara sinkron meningkatkan tingkat pengetahuan.

Pencerahan: PR bukan hanya proses tinjauan kode, tetapi juga kesempatan alat AI untuk berevolusi sendiri.

6. Subagen (Subagents): Biarkan Claude Mengeksekusi Tugas Kompleks Secara Modular

Selain alur tugas utama, Boris juga mendefinisikan beberapa subagen (Subagents) untuk menangani tugas bantu umum.

Subagen adalah beberapa modul yang berjalan otomatis, misalnya:

  • code-simplifier: Setelah Claude menulis kode, secara otomatis menyederhanakan struktur
  • verify-app: Menjalankan pengujian lengkap, memverifikasi apakah kode baru dapat digunakan
  • log-analyzer: Menganalisis log kesalahan, dengan cepat menemukan masalah

Subagen ini seperti plugin, secara otomatis terhubung ke alur kerja Claude, berjalan secara kolaboratif otomatis, tidak perlu prompt berulang.

Pencerahan: Subagen adalah "anggota tim" Claude, meningkatkan Claude dari asisten menjadi "komandan proyek".

Claude bukan hanya satu orang, tetapi Anda dapat membawa tim kecil sebagai manajer umum.

7. Paragraf Tambahan Satu: PostToolUse Hook — Penjaga Terakhir Format Kode

Dalam sebuah tim, membuat setiap orang menulis kode dengan gaya yang seragam tidak mudah. Meskipun kemampuan generasi Claude kuat,难免会有缩进差一点、空行多一点这类细节瑕疵 (seringkali ada cacat detail seperti indentasi sedikit berbeda, baris kosong sedikit lebih banyak).

Cara Boris adalah mengatur sebuah PostToolUse Hook—

Secara sederhana, ini adalah "pengait pasca-pemrosesan" yang secara otomatis dipanggil Claude setelah "menyelesaikan tugas".

Fungsinya termasuk:

  • Memperbaiki format kode secara otomatis
  • Melengkapi komentar yang terlewat
  • Menangani kesalahan lint, menghindari CI gagal
    • Langkah ini biasanya tidak rumit, tetapi sangat penting. Seperti menjalankan Grammarly sekali lagi setelah artikel selesai ditulis, sehingga karya yang diserahkan stabil dan rapi.

      Bagi alat AI, kunci yang mudah digunakan seringkali tidak terletak pada kekuatan generasi, tetapi pada kemampuan penyelesaian.

      8. Manajemen Izin: Pra-otorisasi Alih-alih Melewati

      Boris dengan jelas menyatakan bahwa dia tidak menggunakan --dangerously-skip-permissions — ini adalah parameter Claude Code, dapat melewati semua prompt izin saat mengeksekusi perintah.

      Kedengarannya nyaman, tetapi juga bisa berbahaya, seperti menghapus file secara tidak sengaja, menjalankan skrip yang salah, dll.

      Alternatifnya adalah:

      1.Menggunakan perintah /permissions untuk secara eksplisit menyatakan perintah mana yang tepercaya

      2.Menulis konfigurasi izin ini ke .claude/settings.json

      3.Membagikan pengaturan aman ini ke seluruh tim

      Ini seperti membuka sejumlah "daftar putih" operasi untuk Claude sebelumnya, misalnya:

      "preApprovedCommands": [

      "git commit",

      "npm run build",

      "pytest"

      ]

      Claude menemukan operasi ini dan langsung mengeksekusi, tidak perlu setiap kali menyela.

      Desain mekanisme izin ini lebih seperti sistem operasi tim, bukan alat tunggal. Dia menggunakan perintah /permissions untuk memberikan otorisasi sebelumnya pada perintah bash yang umum dan aman, konfigurasi ini disimpan di .claude/settings.json, dibagikan oleh tim.

      Pencerahan: Otomatisasi AI tidak berarti lepas kendali. Memasukkan strategi keamanan ke dalam proses otomatisasi itu sendiri adalah rekayasa yang sebenarnya.

      9. Keterkaitan Multi-Alat: Claude = Robot Serba Bisa

      Boris tidak hanya menyuruh Claude menulis kode secara lokal. Dia mengonfigurasi Claude agar dapat mengakses beberapa platform inti melalui MCP (modul layanan kontrol pusat):

      • Mengirim notifikasi Slack secara otomatis (misalnya hasil build)
      • Mengkueri data BigQuery (misalnya metrik perilaku pengguna)
      • Mengambil log Sentry (misalnya pelacakan异常 online)

      Bagaimana cara mencapainya?

      Konfigurasi MCP disimpan di .mcp.json

      Claude saat berjalan akan membaca konfigurasi, secara mandiri mengeksekusi tugas lintas platform

      Seluruh tim berbagi satu set konfigurasi

      Semua ini diintegrasikan dengan Claude melalui MCP (sistem kontrol pusat Claude), konfigurasi disimpan di .mcp.json.

      Claude seperti asisten robot, dapat membantu Anda:

      "Menulis kode → mengirim PR → melihat efek → memberi tahu QA → melaporkan log".

      Ini bukan lagi alat AI dalam arti tradisional, melainkan pusat saraf sistem rekayasa.

      Pencerahan: Jangan biarkan AI hanya bekerja di "dalam editor",

      Itu dapat menjadi pengatur dalam seluruh ekosistem sistem Anda.

      10. Pemrosesan Asinkron Tugas Panjang: Agen latar belakang + plugin + hook

      Dalam proyek nyata, Claude terkadang harus menangani tugas panjang, misalnya:

      • Build + test + deploy
      • Menghasilkan laporan + mengirim email
      • Skrip migrasi data sedang berjalan

      Cara penanganan Boris sangat rekayasa:

      Tiga cara menangani tugas panjang:

      1.Claude setelah selesai, menggunakan Agen latar belakang untuk memverifikasi hasil

      2.Menggunakan Stop Hook, secara otomatis memicu tindakan lanjutan saat tugas berakhir

      3.Menggunakan plugin ralph-wiggum (diusulkan oleh @GeoffreyHuntley) untuk mengelola status alur panjang

      Dalam skenario ini, Boris akan menggunakan:

      --permission-mode=dontAsk

      Atau memasukkan tugas ke dalam sandbox untuk dijalankan, menghindari gangguan seluruh alur karena prompt izin.

      Claude bukan "mengawasi setiap saat", tetapi kolaborator yang dapat Anda percayakan.

      Pencerahan: Alat AI tidak hanya cocok untuk operasi singkat dan cepat, tetapi juga untuk siklus panjang, alur kompleks — syaratnya adalah Anda harus membangun "mekanisme perwalian" untuknya.

      11. Mekanisme Verifikasi Otomatis: Output Claude Berharga atau Tidak, Kuncinya Apakah Dapat Memverifikasi Dirinya Sendiri

      Poin terpenting dalam pengalaman Boris adalah:

      Hasil apa pun yang dikeluarkan Claude, harus memiliki "mekanisme verifikasi" untuk memeriksa kebenarannya.

      Dia akan menambahkan skrip verifikasi atau hook untuk Claude:

      • Setelah menulis kode, Claude secara otomatis menjalankan kasus uji untuk memverifikasi apakah kode benar
      • Dalam browser interaksi pengguna simulasi, memverifikasi pengalaman front-end
      • Secara otomatis membandingkan log, metrik sebelum dan sesudah berjalan

      Jika tidak lulus, Claude akan secara otomatis memodifikasi, mengeksekusi ulang. Sampai lulus.

      Ini seperti Claude sendiri membawa "sistem umpan balik tertutup".

      Ini tidak hanya meningkatkan kualitas, tetapi juga mengurangi beban kognitif manusia.

      Pencerahan: Yang benar-benar menentukan kualitas hasil AI, bukanlah jumlah parameter model, tetapi apakah Anda telah merancang "mekanisme pemeriksaan hasil" untuknya.

      Kesimpulan: Bukan Membuat AI Menggantikan Manusia, Tetapi Membuat AI Bekerja Sama Seperti Manusia

      Metode Boris tidak bergantung pada "fitur tersembunyi" atau teknologi canggih, tetapi menggunakan Claude secara rekayasa, meningkatkannya dari "alat obrolan" menjadi bagian dari sistem kerja yang efisien.

      Metode penggunaan Claude-nya memiliki beberapa karakteristik inti:

      • Paralel multi-sesi: Pembagian tugas lebih jelas, efisiensi lebih tinggi
      • Perencanaan diutamakan: Mode Rencana meningkatkan tingkat penyelarasan tujuan Claude
      • Dukungan sistem pengetahuan: Tim bersama-sama memelihara basis pengetahuan AI, beriterasi terus-menerus
      • Otomatisasi tugas: Perintah Slash + subagen, membuat Claude bekerja seperti mesin alur
      • Mekanisme umpan balik tertutup: Setiap output Claude memiliki logika verifikasi, memastikan hasil stabil dan andal

      Sebenarnya metode Boris menunjukkan cara baru menggunakan AI:

      • Meningkatkan Claude dari "asisten dialog" menjadi "sistem pemrograman otomatis"
      • Mengubah akumulasi pengetahuan dari otak manusia menjadi basis pengetahuan AI
      • Mengubah alur dari operasi manual berulang menjadi alur kerja otomatis yang ter-skrip, modular, dan kolaboratif

      Praktik ini tidak bergantung pada sihir hitam, tetapi merupakan cerminan kemampuan rekayasa. Anda juga dapat meminjam ide dari sini, menggunakan Claude atau alat AI lainnya dengan lebih efisien dan cerdas.

      Jika saat menggunakan Claude, Anda sering merasa "dia mengerti sedikit, tetapi tidak dapat diandalkan", "kode yang ditulis selalu harus saya perbaiki", mungkin masalahnya bukan pada Claude, tetapi Anda belum memberinya mekanisme kolaborasi yang matang.

      Claude dapat menjadi magang yang memenuhi syarat, atau也可以成为稳定可靠的工程搭档 (juga dapat menjadi mitra rekayasa yang stabil dan andal), tergantung bagaimana Anda menggunakannya.

相关问答

QApa inti dari pendekatan Boris Cherny dalam menggunakan Claude Code?

AInti pendekatan Boris adalah mengubah Claude dari sekadar alat menjadi 'mitra otomatisasi' dalam alur kerja pengembangan. Dia menggunakan Claude sebagai sistem kolaborasi cerdas yang terintegrasi dalam proses engineering, dengan fokus pada perencanaan, paralelisasi, pengetahuan tim, dan mekanisme verifikasi otomatis.

QMengapa Boris merekomendasikan penggunaan model Opus 4.5 meskipun lebih lambat?

AKarena model Opus 4.5 lebih pintar, kemampuan pemahaman dan penggunaan tools-nya lebih baik, mengurangi kebutuhan komunikasi bolak-balik, dan secara keseluruhan menghemat waktu dengan mengurangi kesalahan dan pekerjaan ulang.

QBagaimana cara Boris menggunakan multiple instance Claude secara paralel?

ABoris membuka 5 instance Claude lokal di terminal, 5-10 session di browser, dan menggunakan aplikasi iOS Claude, masing-masing untuk tugas berbeda seperti refactoring, testing, dan debugging, dikelola seperti sistem multi-thread.

QApa fungsi dari knowledge base tim yang dikelola Boris?

AKnowledge base berfungsi sebagai wiki internal untuk Claude yang berisi best practices tim, cara penulisan kode yang benar, dan pelajaran dari kesalahan sebelumnya. Ini memungkinkan Claude belajar dari pengalaman kolektif tim dan menghindari kesalahan berulang.

QMengapa mekanisme verifikasi otomatis sangat penting dalam penggunaan Claude?

AMekanisme verifikasi otomatis memastikan bahwa output yang dihasilkan Claude sudah benar sebelum digunakan. Claude dapat menjalankan test case, menguji interaksi pengguna, dan membandingkan metrics, lalu memperbaiki sendiri jika gagal, sehingga mengurangi beban kognitif manusia dan meningkatkan kualitas hasil.

你可能也喜欢

Cursor,为什么上了马斯克的飞船?

美国当地时间6月16日,SpaceX在完成史上最大规模IPO仅四天后,宣布以600亿美元全股票交易收购AI编程初创公司Cursor的母公司Anysphere,交易预计于2026年第三季度完成。消息公布后,SpaceX股价一度大涨,市值短暂突破2.94万亿美元。 Cursor是全球热门AI编程工具之一,支持在多家主流AI模型间切换,可自动生成、编辑和审查代码。其年化营收增长迅猛,从2025年11月的10亿美元迅速增长至2026年初的40亿美元。然而,随着其主要AI供应商Anthropic推出竞争产品Claude Code,Cursor市场占有率有所下滑,面临被核心供应商制约的风险。 Cursor的CEO迈克尔·特鲁尔年少成名,拥有出色的编程天赋。面对竞争与依赖风险,Cursor于2026年初决定自研AI模型Composer,但缺乏足够算力。今年4月,Cursor与SpaceX达成合作,后者获得了收购选择权。SpaceX完成IPO后迅速行使该权利,宣布收购。 对Cursor而言,此次收购使其能接入SpaceX强大的Colossus超算系统,解决算力瓶颈。对SpaceX而言,则能借助Cursor在顶尖开发者中的渗透力,提升其AI模型(如Grok)的编程能力,实现在AI竞赛中的弯道超车。 此外,收购也服务于SpaceX更宏大的AI战略,包括探索部署轨道数据中心。马斯克为SpaceX设定了2030年约1万亿美元营收的雄心目标。此次收购是双方各取所需的一场豪赌,特鲁尔将其形容为“前所未有”的特别经历。

链捕手11分钟前

Cursor,为什么上了马斯克的飞船?

链捕手11分钟前

越涨越危险?SpaceX估值狂飙背后的系统性风险

本文就SpaceX市值在盘后交易中突破3万亿美元、超越亚马逊和微软的现象,提出一个核心关切:当前资本市场机制可能已从“价格发现”异化为“制造价格”的自我强化投机机器,并埋下系统性风险。 文章指出,推动SpaceX估值狂飙的主要力量并非其基本面(公司仍处亏损),而是市场结构因素:包括有限的流通盘、即将开始的期权交易(可能引发类似特斯拉过去的“gamma squeeze”逼空循环)、做市商对冲行为、动量资金追逐以及被动资金配置。这种机制使得价格上涨本身成为看涨理由,估值与经济现实脱钩。 作者担忧,若这种趋势持续,SpaceX市值膨胀到5万亿甚至10万亿美元,它将因其巨大规模被强制纳入各类主要指数和被动投资组合(如ETF、养老金)。届时,其估值波动将直接影响整个市场表现,使单一公司的投机性泡沫转化为广泛的系统性风险——当所有人都无法避开它时,即便一次温和回调也可能冲击无数普通投资者的长期资产。 因此,本文的讨论超越了SpaceX是否值这个价钱,而是警示现代金融市场存在的结构性悖论:当叙事、杠杆和流动性能够压倒基本面时,市场是否已丧失其资本配置与价格发现的根本功能?SpaceX只是一个极端案例,但它折射的问题可能更为普遍和危险。

marsbit16分钟前

越涨越危险?SpaceX估值狂飙背后的系统性风险

marsbit16分钟前

你交给Claude的订阅费,光模块公司能拿到多少?

一张将Claude Pro约20美元月费拆解给模型公司、云算力、GPU折旧、电力及供应链的估算图,引发了投资者对AI应用估值逻辑的重新审视。 核心问题在于:用户为AI应用支付的订阅费,有多少能像传统SaaS(软件即服务)那样沉淀为高软件毛利?传统SaaS新增用户成本极低,毛利率可达70%-80%。而AI应用不同,用户每一次调用模型(推理)都会消耗GPU算力、电力和云资源,导致边际成本显著。固定月费背后是随使用量波动的成本链,重度用户的成本可能急剧上升。 因此,AI应用公司要获得高估值,不仅需证明用户付费意愿,更需证明在考虑使用量后,其毛利率能持续改善并接近传统软件公司。当前阶段,AI使用量的增长更直接地转化为对底层基础设施(如英伟达GPU、台积电芯片、HBM内存、电力及数据中心)的需求,这使得基础设施供应商的业绩和估值更早、更确定地得到验证。 支持AI应用高毛利前景的观点认为,当前推理成本高是早期现象。通过模型优化、缓存技术、使用小模型、自研芯片以及提高集群利用率,单位成本有望快速下降。行业已有案例显示,部分模型的单位成本大幅降低。 然而,挑战在于,AI应用正从简单问答转向更复杂、耗能更高的任务(如代码生成、长文档处理)。关键在于,推理成本下降的速度能否超越用户使用量和任务复杂度的增长速度。 总之,该分析图的价值在于提醒市场:在AI应用公司缺乏透明毛利率数据的情况下,不应简单将其收入等同于高毛利SaaS收入。投资者需要关注其成本结构、用户使用行为分层以及效率提升的实际证据。模型公司最终需要证明,即使在重度使用下,订阅收入也能转化为可观的利润。

marsbit26分钟前

你交给Claude的订阅费,光模块公司能拿到多少?

marsbit26分钟前

OpenAI的Hyperliquid盘前定价生意,为何只撑了半年?

文章讨论了在Hyperliquid平台上两家从事“盘前定价”业务的团队:Trade.xyz和Ventuals的不同命运。 Trade.xyz团队匿名,却成为平台上最大的盘前合约市场,成功抓住了SpaceX上市前的交易机会。其策略聪明之处在于,选择像SpaceX这样上市日期和发行价都已确定的标的,最终价格能与现实市场“锚定”,风险相对可控。 而获得顶级风投Paradigm支持的Ventuals,手握OpenAI和Anthropic这类更稀缺但无明确上市计划的标的,反而在运营九个月后关停。其失败关键在于定价机制存在缺陷:合约价格一半依赖外部非公开的老股报价,另一半则参考其自身价格的均线,形成了一个自我强化的循环。这导致价格长期虚高,缺乏真实市场流动性的支撑和纠错,最终失去市场认可。 Ventuals关停时,其定出的OpenAI(1341.80美元)和Anthropic(1618.90美元)的最终价,甚至被部分内部人士作为估值参考,凸显了未上市公司对流动定价的强烈需求,也暴露了这类定价的脆弱性。 文章指出,为未上市明星公司提供实时交易价格正成为一门热门生意,Coinbase等大机构也已入场。但Ventuals的案例表明,这门生意的核心挑战在于,缺乏一个公开、有效、能持续纠错的市场机制来形成真正公允的价格。在标的公司真正上市前,任何定价都可能面临“悬空”的风险。

marsbit42分钟前

OpenAI的Hyperliquid盘前定价生意,为何只撑了半年?

marsbit42分钟前

交易

现货
合约

热门文章

如何购买VIRTUAL

欢迎来到HTX.com!我们已经让购买Virtuals Protocol(VIRTUAL)变得简单而便捷。跟随我们的逐步指南,放心开始您的加密货币之旅。第一步:创建您的HTX账户使用您的电子邮件、手机号码注册一个免费账户在HTX上。体验无忧的注册过程并解锁所有平台功能。立即注册第二步:前往买币页面,选择您的支付方式信用卡/借记卡购买:使用您的Visa或Mastercard即时购买Virtuals Protocol(VIRTUAL)。余额购买:使用您HTX账户余额中的资金进行无缝交易。第三方购买:探索诸如Google Pay或Apple Pay等流行支付方法以增加便利性。C2C购买:在HTX平台上直接与其他用户交易。HTX场外交易台(OTC)购买:为大量交易者提供个性化服务和竞争性汇率。第三步:存储您的Virtuals Protocol(VIRTUAL)购买完您的Virtuals Protocol(VIRTUAL)后,将其存储在您的HTX账户钱包中。您也可以通过区块链转账将其发送到其他地方或者用于交易其他加密货币。第四步:交易Virtuals Protocol(VIRTUAL)在HTX的现货市场轻松交易Virtuals Protocol(VIRTUAL)。访问您的账户,选择您的交易对,执行您的交易,并实时监控。HTX为初学者和经验丰富的交易者提供了友好的用户体验。

902人学过发布于 2024.12.23更新于 2026.06.02

如何购买VIRTUAL

相关讨论

欢迎来到HTX社区。在这里,您可以了解最新的平台发展动态并获得专业的市场意见。以下是用户对VIRTUAL(VIRTUAL)币价的意见。

活动图片