标签：#claude

⚠️ この記事はアフィリエイト広告（プロモーション）を含みます。リンク先で発生した収益の一部が運営者に支払われますが、読者の購入価格には一切影響ありません。 By the end of this article you will have a GitHub Actions workflow that, on every pull_request , runs the Claude Code SDK headlessly, reads only the diff, and posts inline review comments via the GitHub API. I'll show the exact YAML and Python that run in my own repos, the token math that keeps each review at roughly $0.03, and the three failures that cost me a weekend before it worked. Why I stopped piping the full repo into Claude on GitHub Actions My first version did the obvious thing: clone the repo, concatenate every changed file in full, and ask Claude to "review this PR." It worked on toy PRs and exploded on real ones. A 9-file refactor sent ~48,000 input tokens and the review drifted into commentary about code the PR didn't touch. The fix that changed the economics: feed Claude the unified diff with 3 lines of context , not the files. A git diff against the merge base is typically 5–15x smaller than the files it touches. On claude-haiku-4-5 , a median PR in my projects now costs about $0.028 per review (measured across 60 PRs: 4,100 input tokens + 900 output tokens average). The expensive version was hitting $0.40+ on Sonnet because file context dominated. The other lesson: the diff alone is not enough context to judge correctness, but it is enough to catch the 80% of review nits that humans waste time on — unhandled errors, missing null checks, off-by-one, leftover debug prints, secrets in code. So I scoped the prompt to exactly that, and told it to stay silent when unsure. Silence is a feature; a reviewer that comments on everything gets muted by the team within a week. The GitHub Actions workflow YAML that triggers Claude on pull_request This is the full .github/workflows/claude-review.yml . It runs on every PR, restores a uv-cached venv, and calls a Python entrypoint. Note the permissions block — without pull-requests: write the comment-posting step fails with a 403 that GitH

In the first post I told you the story: 20 years as a developer, six months of being scared of AI, $800 in burned tokens, and a stubborn agent named Claudio who taught me — by failing over and over — how to ask for things properly. This post is the method that came out of all that pain. Five rules, one per letter of FORGE. I want to be honest about one thing up front: this is not a framework I invented at a whiteboard. Every rule here is a scar. Each one is the lesson from a specific mistake that cost me money, time, or sleep. I'm going to tell you the mistake first, and then the rule. Because the rule only makes sense once you've felt the pain that created it. Let's go. First, the idea behind all of it Here's the thing nobody told me when I started: A task is not a post-it. It's a contract. When you ask an AI agent for something with no structure, you're not giving an order — you're placing a bet. The agent interprets, assumes, improvises, and the result depends on how much context it managed to reconstruct on its own. Sometimes it guesses right. Often it doesn't. And you only find out after the tokens are gone. The Forge Method is the agreement between you and your agents: you bring the structure, they execute with precision . That's it. Five rules to hold up your end of that contract. F — Focused The mistake: My early tasks had titles like "Fix bug" and "Update stuff." I'd come back twenty minutes later to find the agent had fixed a bug — just not the one I meant. It wasn't wrong. It just had no way of knowing which thing I was talking about. **The rule: **If the title is vague, the task is vague. Vague in, vague out. A focused title needs a domain, an action, and a scope. Two words minimum, and no generic placeholders. ❌ Rejected: - "Fix bug" - "Update auth" - "Do the thing" ✅ Accepted: - "Fix authentication timeout on Nginx reverse proxy" - "Update JWT expiry from 1h to 24h in src/auth/config.ts" The test: Read the title with no context. Do you know the domain,

멀티 에이전트(Multi-agent) AI 시스템은 여러 AI 에이전트가 역할을 분담하고 서로 통신하면서 복잡한 업무를 자율적으로 처리하는 구조다. 한 에이전트가 처음부터 끝까지 처리하는 싱글 에이전트와 달리, 검색·분석·실행·검증을 각각 다른 에이전트가 병렬로 맡고 그 결과를 조율(orchestration)한다. 2026년 한국 기업 AI 도입은 단일 챗봇 단계를 지나, 다단계 의사결정과 도메인 특화 작업을 자동화하는 멀티 에이전트 단계로 이동 중이다. 이 글은 멀티 에이전트와 싱글 에이전트의 구조적 차이, 도입 비용·기간·실패 위험, 국내 도입 사례, 외주 발주 시 업체 선택 기준까지 발주 담당자가 의사결정에 바로 쓸 수 있는 비교표·체크리스트를 제공한다. 멀티 에이전트와 싱글 에이전트, 무엇이 다른가? 싱글 에이전트는 하나의 LLM 인스턴스가 도구(tool)를 직접 호출하면서 모든 단계를 처리한다. 작업 흐름이 선형적이고 컨텍스트가 한곳에 모이므로 구현이 단순하다. 반면 멀티 에이전트는 작업을 여러 하위 작업으로 쪼개고, 각 에이전트가 자기 역할(role)·시스템 프롬프트·도구 집합을 따로 가진 채 협업한다. 가장 흔한 패턴 세 가지를 정리하면 다음과 같다. Supervisor 패턴 : 상위 supervisor 에이전트가 작업을 받아 worker 에이전트들에게 분배하고 결과를 통합한다. 의사결정 라인이 명확해 디버깅이 쉽다. Peer 패턴 : 동등한 에이전트들이 메시지 큐로 정보를 주고받으며 합의(consensus)를 이룬다. 창의적 결과가 필요한 리서치·기획에 적합하다. Hierarchical 패턴 : supervisor 아래 sub-team을 두고, sub-team 안에서 다시 supervisor-worker 구조를 반복한다. 대규모 RPA·복합 업무 자동화에 쓰인다. 구분 싱글 에이전트 멀티 에이전트 적합한 작업 1~3단계 선형 작업 5단계 이상, 분기·검증 필요 컨텍스트 관리 단일 컨텍스트 윈도우 에이전트별 분리 + 공유 메모리 토큰 비용 낮음 1.8~3배 (병렬·검증 오버헤드) 구현 난이도 낮음 높음 (조율·실패 처리) 정확도 단순 작업에 충분 복잡 작업에서 10~25%p 향상 외주 비용(국내) 800만~3,000만 원 3,000만~1.2억 원 구축 기간 4~8주 10~16주 Anthropic의 멀티 에이전트 리서치 시스템 사례 에서는 단일 Claude 에이전트 대비 멀티 에이전트 구조가 리서치 품질 평가에서 약 90% 더 높은 점수를 받았다. 다만 토큰 사용량은 약 15배로 늘어, 모든 작업에 멀티 에이전트가 정답은 아니라는 점도 같은 글에서 강조한다. 언제 멀티 에이전트가 필요한가? — 도입 판단 트리 발주 담당자가 자주 묻는 질문은 "우리 업무에 멀티 에이전트가 정말 필요한가"이다. 다음 네 가지 조건 중 두 개 이상에 해당하면 멀티 에이전트가 ROI를 만든다. 작업이 5단계 이상이고, 각 단계가 다른 전문성을 요구한다 — 예: 시장 리서치 → 경쟁사 분석 → 보고서 작성 → 사실 검증. 결과의 신뢰도가 비즈니스 결정에 직결된다 — 검증 에이전트(critic)를 두면 환각 비율이 의미 있게 떨어진다. 작업 분기(branching)가 데이터에 따라 동적으로 결정된다 — 단순 if/else로는 표현 어려운 휴리스틱 분기. 여러 외부 시스템(SaaS·DB·내부 API)을 동시에 다뤄야 한다 — 도구 권한을 에이전트별로 격리하면 보안 관리도 쉬워진다. 반대로 다음에 해당하면 멀티 에이전트는 과잉이다. 싱글 에이전트로 충분하다. 단순 FAQ 챗봇, 분류·태깅 같은 단발성 작업. 작업당 비용이 100원 미만이어야 하는 대규모 트래픽 환경. 인간 검수자(HITL)가 매번 결과를 확인하는 워크플로우 — 멀티 에이전트의 자율성이 오히려 검수 부담을 늘린다. 나무숲에서도 초기에는 모든 자동화를 싱글 에이전트로 구축했다가, 검증·분기·외부 API 호출이 동시에 일어나는 마케팅 자동화 파이프라인부터 멀티 에이전트로 재설계한 경험이 있다. 무조건 멀티 에이전트가 좋은 게 아니라, 위 네 조건을 충족한 영역만 옮긴 것이

클로드로 한글파일(HWP) 변환·자동화하는 법 2026 — 요약·표 추출·일괄 처리 실전 한글파일을 Claude로 다루려는 한국 기업 실무자가 가장 먼저 부딪히는 벽은 " 읽기는 됐는데, 그래서 뭘 어떻게 자동화하지? "다. HWP-MCP를 설치해 Claude가 한글 문서를 읽게 만드는 것까지는 HWP-MCP 도입 가이드 에서 다뤘다. 이 글은 그 다음 단계 — 실제 업무에서 한글파일을 요약·변환·일괄 처리하는 구체적 방법 을 실전 예시로 보여준다. 한글파일 AI 자동화의 핵심은 "한컴 오피스 라이선스 없이, 사람 손을 거치지 않고, 반복 작업을 Claude에게 위임하는 것"이다. 계약서 100건 요약, 요구사항서의 표를 CSV로 추출, 폴더 안 HWP 일괄 변환 — 이런 작업이 자동화 대상이다. 한글파일 자동화로 풀 수 있는 업무 3가지 업무 수동 작업 시간 자동화 후 적용 키워드 문서 요약 1건당 10~15분 50건 30초 claude 한글파일 요약 표 → 데이터 추출 1표당 5분 (재입력) 표 자동 CSV 변환 hwp 표 추출 일괄 변환·정리 100건 8시간 100건 1시간 20분 한글파일 일괄 처리 세 업무 모두 "사람이 한글파일을 열어 읽고, 내용을 옮겨 적는" 반복 작업이다. Claude + HWP-MCP 조합은 이 중간 단계를 없앤다. 전제: HWP-MCP 연결 확인 자동화에 들어가기 전, Claude가 한글파일을 읽을 수 있는 상태인지 확인한다. (설치 절차는 HWP-MCP 도입 가이드 참조.) # Claude Desktop 설정에서 hwp-mcp 서버가 연결됐는지 확인 # MCP 도구 목록에 hwp_read, hwp_extract_tables 등이 보여야 함 연결이 확인되면 아래 3가지 워크플로우를 바로 쓸 수 있다. 워크플로우 1: 한글파일 요약 자동화 계약서·보고서·요구사항서처럼 길이가 긴 한글 문서를 Claude에게 요약시키는 패턴이다. 단일 문서: "이 한글파일을 읽고 다음 3가지로 요약해줘: 1. 핵심 내용 5줄 2. 의사결정이 필요한 항목 3. 누락되거나 모호한 조항" 여러 문서 일괄 요약: 폴더 경로를 주고 "이 폴더의 모든 .hwp 파일을 각각 위 형식으로 요약하고, 결과를 하나의 마크다운 표로 정리해줘"라고 지시하면, Claude가 HWP-MCP로 파일을 순회하며 처리한다. 50개 문서 기준 약 30초. 요약 품질을 높이는 팁: "요약 기준"을 구체적으로 명시 할수록 결과가 좋다. "계약 금액·기간·위약 조항 중심으로" 같은 도메인 컨텍스트를 주면 일반 요약보다 실무 적합도가 크게 오른다. 워크플로우 2: 표 → CSV 데이터 추출 한글파일의 표는 복사-붙여넣기로 옮기면 서식이 깨지는 게 가장 큰 골칫거리다. HWP-MCP의 표 추출 기능을 쓰면 구조를 유지한 채 데이터만 뽑는다. "이 한글파일에 있는 모든 표를 추출해서 CSV로 변환해줘. 표가 여러 개면 각각 별도 파일로, 헤더 행을 포함해서." 활용 시나리오: 견적서·정산표 : 한글 견적서의 항목·단가·합계를 회계 시스템에 올릴 CSV로 요구사항 명세 : 기능 목록 표를 이슈 트래커(Jira/Linear) import 형식으로 설문·조사 결과 : 한글 보고서의 통계 표를 분석용 데이터프레임으로 표 안에 병합 셀이 있으면 Claude에게 "병합 셀은 상위 값으로 채워줘(forward fill)"라고 미리 지시하는 게 데이터 정합성에 좋다. 워크플로우 3: 폴더 일괄 처리 가장 ROI가 큰 패턴. 수백 개 한글파일이 쌓인 폴더를 통째로 처리한다. "./contracts 폴더의 모든 .hwp 파일에 대해: 1. 계약 상대방·금액·시작일·종료일을 추출 2. 하나의 CSV로 통합 (파일명을 첫 열에) 3. 종료일이 30일 이내인 계약은 ⚠️ 표시" 100건 기준 수동 8시간 작업이 약 1시간 20분으로 줄어든다(실측). 핵심은 추출 스키마를 먼저 정의 하는 것 — 무엇을 뽑을지 명확할수록 일괄 처리 정확도가 높다. python-docx·한컴 API와 무엇이 다른가 방식 한글파일(.hwp) 지원 자동화 난이도 AI 통합 한컴 오피스 자동화

Claude Code에서 Codex로 옮길 때 — 실전 마이그레이션 가이드 2026 Claude Code 기반 워크플로우를 OpenAI Codex CLI로 옮기려는 팀이 늘고 있다. 모델 가격, 멀티 벤더 리스크 분산, 특정 코딩 워크로드의 성능 차이 등 이유는 다양하다. 그런데 두 도구는 같은 "AI 코딩 에이전트"라는 카테고리에 속해도 컨벤션·확장 메커니즘이 다르다. 무작정 옮기면 자동화 파이프라인의 절반이 깨진다. 이 가이드는 Claude Code → Codex 마이그레이션을 실제로 끝내본 팀이 어떤 순서로 무엇을 옮기고, 무엇을 포기하고, 무엇을 대체했는지 정리한다. 자동 변환 툴( claude2codex )을 어디서 쓰고 어디서 안 쓰는지, 일주일 점검 체크리스트, 양쪽을 분기 사용하는 하이브리드 패턴까지 다룬다. 마이그레이션 전 의사결정 — 옮길지 말지부터 옮기는 게 모두에게 정답은 아니다. 다음 세 질문에 모두 "예"여야 본격 마이그레이션을 권한다. 현재 Claude Code 비용의 60% 이상이 일상적인 코드 편집·리뷰에서 발생하는가? (Codex의 GPT-5-codex가 단가 우위를 보이는 영역) — 만약 디자인·기획·문서 분량이 큰 워크플로우라면 Claude를 유지하는 게 합리적이다. Skills·Hooks·서브에이전트 같은 Claude 고유 기능에 의존하지 않는가? 의존도가 높다면 마이그레이션 비용이 비용 절감을 초과한다. 하나의 벤더 락인을 줄이는 게 중요한 전략적 우선순위인가? 멀티 벤더 운영은 그 자체로 관리 비용이 든다. 세 질문 중 하나라도 "아니오"라면, 통째 마이그레이션 대신 하이브리드 분기 사용 (아래 5절)이 더 낫다. Claude Code와 Codex의 핵심 차이 비교 영역 Claude Code OpenAI Codex CLI 마이그레이션 난이도 메인 모델 claude-opus-4-7 / sonnet-4-6 / haiku-4-5 GPT-5 / GPT-5-codex / o1 계열 낮음 (모델 교체) 컨벤션 파일 CLAUDE.md AGENTS.md (멀티 벤더 표준) 낮음 (rename + 어조 조정) 확장 메커니즘 Skills (markdown SKILL.md + 메타데이터) 별도 표준 없음, 수동 컨텍스트 로딩 높음 (가장 큰 갭) 자동화 훅 Hooks (PreToolUse, SessionStart, UserPromptSubmit 등) 라이프사이클 이벤트 미지원 높음 (외부 wrapper 필요) 슬래시 커맨드 /명령 형태 + 인자 파싱 CLI 인자로 대체 중간 MCP 서버 1급 지원, 자동 도구 노출 일부 지원, 설정 형식 다름 중간 서브에이전트 Agent tool (subagent_type) 외부 오케스트레이션 필요 높음 권한 모드 acceptEdits / plan / dontAsk 등 --auto / --confirm 류 낮음 가장 큰 갭 세 곳: Skills · Hooks · 서브에이전트 . 이 세 가지에 깊이 의존하는 팀은 마이그레이션 ROI가 마이너스로 나올 수 있다. 마이그레이션 절차 — 7단계 1단계: 자산 인벤토리 (1일) .claude/ 디렉토리, CLAUDE.md , 프로젝트 루트의 slash command 정의, hook 설정, MCP 서버 목록을 전부 추출한다. find . -path "*/.claude/*" -type f > migration/inventory.txt ls .claude/skills/ .claude/hooks/ .claude/commands/ 2>/dev/null >> migration/inventory.txt cat .claude/settings.json | jq '.mcpServers // {}' > migration/mcp.json 이 파일들이 모두 변환되거나, 대체되거나, 폐기되는지 명시적으로 매핑되어야 한다. "그냥 옮기면 되겠지"는 거의 항상 일주일 후 장애로 돌아온다. 2단계: claude2codex 자동 변환 적용 (반나절) 오픈소스 claude2codex 마이그레이션 툴 이 자동으로 처리하는 것: CLAUDE.md → AGE

AI Builder Notes - May 2026 AI-assisted notes from my liked-tweets feed, organized around agent workflows, browser traces, model loops, and guardrails. Practical takeaways Start with the workflow, not the agent. A useful agent task has a source of truth, a narrow action, a verifier, and a stop condition. “Review this repo” is vague. “Find auth bugs in these routes, cite file lines, run the relevant tests, and stop after the first credible exploit path” is a workflow. Use dynamic workflows in claude code - to do the vibe bits for thinking through a workflow. Think of it like this - you can describe in natural language an entire workflow consisting of multiple agents at various steps - I want the docs updated, tests passed, security review done and also playwright tests done. Dynamic workflows figures out which parts can be divided in parallel and what should be done sequentially. Creates a flowchart - and writes JS code for it. Its a JS script that can execute subagents at scale and deterministically [1] Planner/executor split is the way to go. Spend the expensive model on taste, decomposition, and risk discovery. Use cheaper or narrower models for repeatable implementation once the task has tests, rubrics, logs, or examples. [2] Do not judge an agent workflow by the model name alone. If the loop has repo access, a rubric, a way to inspect tool calls, and a verifier, a less fashionable model can still do useful work. The Letta Code / GLM 5.1 review-bot example is interesting for that reason, not because “someone used X instead of Y” is interesting by itself. [3] Prefer small interfaces to giant tool menus. MCP tool call definitions are rotting your context! The monday.com GraphQL example was the clearest cost warning: one task used 15k tokens through SDK/code-mode and 158k tokens through a real MCP server. MCP is useful, but a menu of tools is not automatically an efficient interface. [4] [5] For browser work, save the trace. Run the workflow once, inspect wasted act

Anthropic introduced Dynamic Workflows, a new capability for Claude Code designed to handle complex software engineering tasks by coordinating large numbers of AI agents within a single workflow. The feature allows Claude to dynamically create orchestration scripts, break work into subtasks, run them in parallel, and validate results before presenting a final answer. By Robert Krzaczyński

The use of AI Agents creates a distinctive smell... One can tell the GH Repo owner was high on...

RecursiveMAS (arXiv 2604.25917) showed that agents sharing internal reasoning state outperform agents that share only final outputs. The average accuracy gain across benchmarks was 8.3 points. The mechanism: each agent passes not just its answer but the latent embeddings from its own reasoning process, and the next agent conditions on both. The paper is a good result. The catch is access. RecursiveMAS requires open-weight models with hidden states exposed at inference time. That rules out Claude, GPT-4o, and Gemini. I built a Claude-native version using the Anthropic extended thinking API. The core idea transfers: instead of passing latent vectors, pass the full thinking text. The paper calls it internal state sharing; the Claude version calls it thinking-block relay. The architecture problem Claude's extended thinking blocks carry an encrypted signature tied to the originating conversation. You cannot pass a signed thinking block into a different agent's messages array. The API rejects it. The workaround: extract the text from the thinking block and inject it as a regular user message. # Extract thinking text from Agent 1 thinking_text = next ( ( b . thinking for b in response . content if b . type == " thinking " ), "" ) # Inject into Agent 2 as regular context, not as a thinking block context = f " Prior agent reasoning: \n { thinking_text } " The signature does not transfer. The reasoning does. relay-structured: what I built first The first architecture was a Planner > Critic > Solver loop where each agent emits a compact mental model JSON instead of raw thinking text. Raw thinking at a 1024-token budget is often compressed and fragmented. The hypothesis was that 150 tokens of structured signal carries more information per token than 1024 tokens of compressed prose. The schema each agent emits: { "interpretation" : "how the agent read the problem" , "key_steps" : [ "step 1" , "step 2" ], "rejected_approaches" : [ "approach tried and discarded" ], "confidence" :

System-prompt caching alone cut repeat-call costs by half Tool definitions cache separately, perfect for agent loops Conversation history caching pays off after turn three 1-hour TTL beats the default 5 minutes for batch jobs My Anthropic API bill dropped 70 percent last month and I did not change a single model. I changed where the cache breakpoints went. Here are the five patterns I now use on every Claude integration I ship. Pattern 1: Cache The System Prompt First The system prompt is the cheapest win and most people skip it. My agents run with a 4,000 token system prompt that explains the role, the output format, the safety rules, and a few examples. That prompt never changes inside a session. Before caching, I paid full input price for those 4,000 tokens on every single call. With an agent that loops 30 times to finish a task, that is 120,000 tokens of pure repetition. The fix is one parameter. I add a cache_control block with type: "ephemeral" to the last content item in the system prompt array. The first call writes the cache and costs slightly more (cache writes carry a small premium). Every call after that reads the cache at roughly one tenth the input price. Here is the rule I follow: the cached block has to be at least 1,024 tokens for Claude Sonnet, or it gets ignored silently. My 4,000 token prompt clears that easily. If your system prompt is short, this pattern does nothing, so do not bother adding the breakpoint to a 200 token instruction. The order matters more than people expect. The cache works as a prefix. Everything before the breakpoint gets stored. Everything after it is read fresh. So I put the stable stuff (role, rules, examples) up top and the volatile stuff (user query, current date) down below the breakpoint. Reorder this wrong and your cache hit rate collapses because the prefix changes on every call. One real number from my logs: a document-classification job that runs 2,000 times a day. The system prompt is 3,800 tokens. Caching it sav

Claude Code — My daily dev tool Claude Code by Anthropic is the one I use the most for development, by far. What sets it apart from the others: it integrates directly into the terminal and editor, it can read and modify files, navigate an entire codebase, and understand the global context of the project. Not just responding to a copy-pasted snippet in a chat window. In practice, when I have an idea, I ask it to structure the project and challenge my choices. And to be clear: I challenge it too. 😄 I sometimes disagree with its suggestions, and that's often where the conversation becomes interesting. It's a tool, not an oracle. Perplexity — My reference for research Perplexity is my main tool when I need a reliable and verifiable answer. It's a response engine that systematically cites its sources — you ask a question, it answers with excerpts from real web pages and direct links. No more hallucinations without references. However, I use it almost exclusively on desktop. On smartphone, it's flooded with messages pushing the paid version. Understandable from their side, but frankly annoying when you just want to do a quick search. 🙄 Gemini — For those in the Google ecosystem Gemini is Google's AI, and its main advantage is integration with Gmail, Docs, Drive, Sheets, and Google Search. I have a Google Pixel, and on that side, it does integrate very well with its own ecosystem. It's practical for analyzing documents or getting a quick summary without leaving the interface. That said, in terms of responses, it sometimes falters. 😬 Not systematically, but regularly enough that I stay on guard. And if privacy is a priority for you, it's worth thinking twice before entrusting it with your documents — I talk about this in my article on securing yourself on the Internet . ChatGPT — The natural entry point ChatGPT by OpenAI is the most known and most versatile AI. Writing, code, analysis, translation, summary, creativity... it does a bit of everything, often very well. The fre

In This Article The Deal Intelligence Gap Data Model Design Transcript Analysis with Claude Automated Follow-Up Drafting PostgreSQL JSONB Storage Putting It Together The Deal Intelligence Gap Most CRM systems are excellent at storing what happened — call logged, email sent, stage updated — and poor at capturing what was learned. A sales call produces qualitative intelligence that is genuinely valuable for deal strategy: what objections surfaced, how strongly the prospect signaled interest, what next steps were agreed to, and what risk flags the conversation revealed. That intelligence almost never makes it into the CRM because it requires someone to spend 15 minutes synthesizing unstructured notes into structured fields. Large language models change this equation. Given a call transcript, Claude can extract structured deal intelligence in seconds — categorizing sentiment, identifying specific objections, recommending stage movement, and flagging risk signals — with accuracy that equals or exceeds what a well-trained sales analyst would produce manually. Data Model Design The data model centers on two tables. The deals table stores core deal attributes as a JSONB column, which allows flexible schema evolution without migrations as the intelligence fields change over time. The deal_activities table records each interaction — calls, emails, meetings — with the raw content in TEXT and the extracted intelligence in a separate JSONB column. A GIN index on both JSONB columns enables fast attribute queries across the deal pipeline. CREATE TABLE deals ( id UUID PRIMARY KEY DEFAULT gen_random_uuid (), company TEXT NOT NULL , contact TEXT , stage TEXT , attributes JSONB DEFAULT '{}' , created_at TIMESTAMPTZ DEFAULT now (), updated_at TIMESTAMPTZ DEFAULT now () ); CREATE TABLE deal_activities ( id UUID PRIMARY KEY DEFAULT gen_random_uuid (), deal_id UUID REFERENCES deals ( id ), activity_type TEXT , raw_content TEXT , intelligence JSONB , created_at TIMESTAMPTZ DEFAULT now () )

Claude Code added Dynamic Workflows. Dynamic Workflows are a way to run larger coding tasks as a...

Opus 4.8 ships Dynamic Workflows — hundreds of parallel subagents per session. Read this before you wire it into prod. Anthropic's Opus 4.8 announcement on May 28 spent most of its word count on benchmarks. CursorBench up. Terminal-Bench 2.1 beats GPT-5.5. OSWorld-Verified at 82.3%. Online-Mind2Web at 84%. The legal-agent benchmark broke 10% on all-pass for the first time. Those are the numbers the headline writers grabbed. Buried under the benchmark table is the line that actually changes how you ship agents: Dynamic Workflows. Run hundreds of parallel subagents. Handle codebase-scale migrations spanning hundreds of thousands of lines. That is not a benchmark. That is a new programming model. And it is shipping as a preview, which means the defaults are not what they will be in 90 days. If you are running agents in production and you do not pin your config before the next minor release, your bill is going to surprise you. Here is what the preview actually does. Three tasks it eats alive. One class of work where it loses you money. And the exact config to pin before the dynamic-workflow defaults move under you. What Dynamic Workflows actually changed Before 4.8, parallel subagents on the Anthropic stack meant one of two things. Either you called the Agent tool from inside Claude Code and got a fixed number of side-task subagents — usually capped somewhere around four or eight concurrent. Or you wrote your own orchestrator in TypeScript or Python, called the Messages API in a Promise.all , and handled the queueing yourself. The Agent path was ergonomic but capped. The DIY path was uncapped but the orchestration was your problem — retries, structured output validation, cache invalidation, all of it. Dynamic Workflows in 4.8 collapses both. You write a script — JavaScript, not a separate orchestrator binary — that calls agent() , parallel() , pipeline() , and phase() as primitives. The runtime handles concurrency, structured output validation against JSON Schema, retri

Here is what a real solo founder orders. $ git worktree list ~/app a1b2c3d [ main] ~/app-review e4f5g6h [ review-branch] ~/app-content i7j8k9l [ draft-post] Three checkouts. One machine. Each one runs its own Claude Code session that cannot touch the others. That is a normal workday for me. I run a one person shop. Content and code, same desk, same hour. Anthropic's common workflows page lists about a dozen recipes for everyday work, and the docs are strong. What they do not tell you is which recipes survive contact with a real workday and which ones stay theory. After running Claude Code as my whole operation, five workflows carry the load. Here is the honest split. https://code.claude.com/docs/en/common-workflows 1. Worktrees changed how I work The problem worktrees solve is collision. You ask Claude to fix a bug. While it edits, you want to keep building a feature. Same repo, two streams of edits, and now your working tree is a fight nobody wins. A git worktree is a second checkout of the same repo on its own branch. Claude runs inside it and never sees the other windows. claude --worktree feature-auth Real scenario from this week. The post you are reading was drafted in one worktree while a separate Claude session reviewed an open pull request in another. Neither touched the other's files. When the review finished I merged, came back to the draft, and never lost my place. If you take one workflow from the docs, take this one. The setup cost is close to nothing and parallel agents stop stepping on each other. 2. Subagents protect the one resource you cannot buy more of The model's working memory is your budget. Every file Claude reads to answer a question spends it. Ask "how does our auth refresh work" in a large repo and Claude reads a pile of files to answer. Those files now sit in the window for the rest of the session, crowding out the work you care about. Delegate that to a subagent. use a subagent to investigate how our auth system handles token refresh The

{/* JSON-LD schema is generated server-side in app/blog/[slug]/page.tsx , do not re-add an inline block here, it crashes<br> MDX&#39;s Acorn parser on the leading <code>{</code>. */}</p> <h2> <a name="tldr" href="#tldr" class="anchor"> </a> TL;DR </h2> <p>In February 2026, Snyk published the <a href="https://snyk.io/blog/toxicskills-malicious-ai-agent-skills-clawhub/">ToxicSkills audit</a>, the first large-scale security review of the public Claude Code skills ecosystem. It scanned 3,984 skills from ClawHub and skills.sh. Findings:</p> <ul> <li><strong>13.4%</strong> contained critical-level issues</li> <li><strong>36%</strong> carried prompt-injection payloads</li> <li><strong>1,467</strong> distinct malicious payloads</li> <li><strong>91%</strong> of confirmed malware combined natural-language jailbreaks with executable shell payloads</li> </ul> <p>If you install a Claude Code skill today without reading its source, the probability that it can read your env vars, exfiltrate <code>~/.ssh/</code>, or chain a bash pipeline that bypasses your deny rules is real and measurable. This post is the cheat sheet for evaluating a skill before you install it. The CTA at the bottom is <a href="https://dev.to/skillvault">SkillVault</a>, the bundle we ship for teams who want this work already done.</p> <h2> <a name="why-the-question-is-suddenly-loadbearing" href="#why-the-question-is-suddenly-loadbearing" class="anchor"> </a> Why the question is suddenly load-bearing </h2> <p>Claude Code skills shipped as an open spec in December 2025. By March 2026, MCP downloads were tracking at 97 million per month, and the most-installed marketplace skill had passed 564,000 installs. <a href="https://venturebeat.com/security/claude-code-512000-line-source-leak-attack-paths-audit-security-leaders">Anthropic&#39;s source leak</a> on March 31, 2026 made the abstract attack surface visceral: the <code>bashSecurity.ts</code> module has 23 numbered security checks, suggesting each was a real incide

클로드를 10%에 팔지 않고, 클로드를 10%에 사는 사람들이 있다 중국 암시장에서 벌어지는 AI 모델 밀수, 그 이면에는 기술 산업의 가장 불편한 진실이 숨어 있다 TL;DR : 앤트로픽의 최고급 AI 모델 '클로드'가 중국 암시장에서 정가의 10% 수준으로 유통되고 있다. 이 현상의 이름은 '모델 증류'다. 거대 기업이 수조 원을 들여 만든 지능을, 누군가는 그 1/10 비용으로 복제해 팔고 있다. 그리고 이것은 단순한 불법 복제 이야기가 아니다 — AI 산업 전체의 구조적 취약점을 정면으로 드러내는 사건이다. 반도체 업계에는 잘 알려지지 않은 규칙이 하나 있다. 좋은 제품을 만드는 것과, 그 제품을 지키는 것은 전혀 다른 게임이라는 것. 엔비디아는 올해 58조 원을 투자해 공급망을 틀어쥐었다. 오픈AI는 GPT 시리즈에 수년간의 연구와 수천억 원의 컴퓨팅 비용을 쏟아부었다. 그런데 중국의 어느 텔레그램 채널에서는, 앤트로픽의 클로드가 정가의 10분의 1 가격으로 조용히 팔리고 있다. 이것이 단순한 해킹이나 계정 공유 이야기라면, 이 글을 쓰지 않았을 것이다. 먼저, '10% 가격'이 의미하는 것 클로드가 10% 가격에 팔린다는 뉴스를 처음 접하면, 많은 사람이 "계정을 불법 공유하는 것 아닐까"라고 생각한다. 어느 정도는 맞는 말이다. 실제로 해외 계정을 공유하거나, 앤트로픽 API 키를 여러 명이 나눠 쓰는 방식은 존재한다. 그러나 전문가들이 더 심각하게 보는 것은 따로 있다. 바로 '모델 증류(model distillation)'다. 모델 증류는, 쉽게 말하면 이렇다. 선생님 모델에게 엄청난 양의 질문을 던진다. 그 답변을 수집한다. 그 답변 데이터로 작은 학생 모델을 학습시킨다. 그러면 학생 모델이 선생님의 사고 패턴과 언어 습관, 추론 방식을 흡수하기 시작한다. 원본 코드에 손을 대지 않아도 된다. 서버에 침입할 필요도 없다. 그냥 열심히 질문하고, 열심히 답변을 모으면 된다. AI 분야에서 이 기법은 사실 합법적으로도 쓰인다. 큰 모델을 작고 효율적인 모델로 압축할 때 사용하는 정상적인 기술이다. 그런데 이것이 암시장과 만나면, 지식재산권의 경계가 극도로 흐려진다. 클로드의 추론 패턴을 흡수한 어느 중국산 모델이 텔레그램에서 월 몇 달러에 팔리고 있을 때, 앤트로픽은 그것을 어떻게 불법이라고 증명할 수 있을까. 코드는 다르다. 서버는 다르다. 그러나 그 모델이 내놓는 답변의 '결'은 묘하게도 클로드를 닮아 있다. 거인이 쌓아올린 것, 그리고 그것이 무너지는 방식 앤트로픽은 2021년 오픈AI에서 나온 연구자들이 세운 회사다. AI 안전성에 집착에 가까운 철학을 가진 곳으로, 클로드를 "도움이 되고, 해가 없으며, 솔직한(Helpful, Harmless, Honest)" 모델로 설계하기 위해 수년간 독자적인 훈련 방식을 개발했다. 이 회사가 투자받은 금액은 수조 원 단위다. 아마존이 단독으로 수십억 달러를 투자했고, 구글도 뒤따랐다. 클로드 3.5 시리즈, 그리고 최근 클로드 4에 이르기까지 앤트로픽이 쌓아온 것은 단순히 코드 몇 줄이 아니다. 수백만 시간의 연구자 노동, 막대한 컴퓨팅 자원, 그리고 인간 피드백 데이터의 정교한 축적이다. 그런데 그 성과물이 중국 암시장에서 10% 가격으로 팔린다는 것은, 단지 "불법 복제"의 문제가 아니다. 이것은 AI 시대의 지식재산권이 얼마나 방어하기 어려운 구조 위에 서 있는지를 보여주는 사례다. 소프트웨어 시대에는 코드를 복사하면 불법이었다. 명확했다. 그러나 AI 모델의 '지능'은 코드가 아니다. 가중치(weight)라고 불리는 수십억 개의 숫자 집합이다. 그리고 그 숫자들이 만들어내는 추론 방식을, 외부에서 관찰하고 모방하는 것을 막을 법적 수단은 아직 세계 어디에도 완비되어 있지 않다. 미국도, 유럽도, 당연히 중국도. 앤트로픽이 쓴 방패 — 그리고 그 한계 앤트로픽은 이 문제를 오래전부터 인식하고 있었다. 이번에 보고된 뉴스는 단지 암시장 유통의 문제만이 아니라, 앤트로픽이 클로드의 '협박 시도'를 막기 위해 어떤 방법을 썼는지도 함께 다루고 있다. 클

Agentic AI coding tools are transforming how we build software. But they share a fundamental constraint: context windows are finite, and as chat sessions grow, AI performance degrades, a phenomenon Anthropic calls context rot . The model loses its grip on early instructions, leading to a frustrating "fix-it loop" where the agent fixes one thing but breaks another. Most of us prompt an agent, let it write code, review it, and repeat. This works beautifully for prototypes. But when you need to build a stable, full-featured product with hundreds of mission-critical acceptance criteria (AC), "vibe-coding" breaks down. The reality is that you get better behavior from agents the same way you get it from humans, by explicitly capturing what good and bad look like, and checking against it . Coming from a systems engineering background in regulated industries, I knew we needed to stop treating agents like conversational chat buddies and start treating them like engineering assets. That's why I built DevCortex : a purpose-built structured intelligence layer that brings systems engineering discipline to agentic workflows. What is DevCortex? DevCortex is an agentic development platform built on one core idea: AI agents work best when they have structured, queryable access to a database of requirements they can interrogate on demand, not a wall of text in a prompt. It sits between the human specification and AI execution using three components: 1. An Agentic-V Model Database: A structured hierarchy mapping your high-level vision (ConOps) to system specs (Specs), individual requirements (Reqs), linked defects (Issues), and an auto-generated Traceability Matrix. 2. An MCP Server: Delivers just-in-time, high-signal context to tools like Claude Code or Open Code. Instead of dumping requirements upfront, the agent queries exactly what it needs, when it needs it. 3. Human Control Planes (Web UI & CLI): A multi-user Web UI with real-time WebSocket feeds to watch your agent work, plus a

The moment I realized AI coding assistants were broken I was building a side project — a simple task manager app. I opened Claude Code, typed: "Add user authentication with email and password login" …and hit enter. Twenty minutes later, I had code. A lot of code. Authentication logic, routes, middleware, even some basic tests. But there was a problem. The frontend (me, on a different day) had assumed a different API shape. The tests only covered the happy path. There was no architecture decision to reference — I just picked JWT because it felt right. And the docker-compose.yml ? It didn't exist yet. I had AI-generated code, but no real software development workflow. What was actually missing Good software isn't just code. Before you write a single line, you need: A spec that everyone (including future-you) agrees on An architecture decision that explains the why Backend and frontend designed to talk to each other Tests that prove things actually work A code review that catches security holes before they ship A deployment config that someone can actually run Normally, a team handles all of this. A PM writes the spec. An architect proposes options. Engineers implement and review each other's work. A DevOps person sets up CI/CD. What if AI could fill all those roles? Building the pipeline I built claude-dev-pipeline — a Claude Code plugin that orchestrates a team of specialized AI agents, each with a specific job. airwaves778899 / claude-dev-pipeline 7-agent full-stack development pipeline plugin for Claude Code — PM → Architect → Backend → Frontend → QA → Reviewer → DevOps claude-dev-pipeline A Claude Code plugin that orchestrates 7 specialized AI agents to take your feature request all the way from requirements analysis to production deployment — with a human-in-the-loop checkpoint at every phase. 中文說明 Why? Writing a feature involves more than just code. You need: A clear spec that everyone agrees on An architecture decision before you write a single line Backend and

The most downloaded and widely used methodology in the Claude Code ecosystem is Superpowers , with over 208k stars⭐️ and 18.5k forks🍴 on GitHub (and counting!) Going from raw Claude Code to using Superpowers is as revolutionary as going from a manual transmission to an automatic. Here's why this analogy holds: Planning Mode vs. Coding Mode When we build with Claude (or Codex, or Gemini...), we're usually in one of two states: planning mode coding mode Like shifting gears in a car🚘, moving between these modes effectively is what makes it all work. Skip the shift, and you're just revving your engine (aka burning context and going nowhere.) Superpowers lets Claude automatically detect and shift between these modes. It picks up on ambiguity in your prompt and ensures it fully understands the task before entering coding mode. No manual shifting required! Slower, but for Good Reason Superpowers can feel slower and less satisfying than raw Claude Code, like how driving an automatic can feel less engaging than a manual. But both serve the same critical purpose: they stop you from blowing up your engine! That said, there's still a time and place for raw Claude. Sometimes you want direct, fast, unmediated output. But that minor gain in speed often isn't worth the added complexity, the ambiguity risk, and the tradeoffs that come with it. The Layer Underneath Entire is building the foundation beneath all of this — capturing every session and decision, and linking it to the commit it produced. It's the full record of how the code was written, not just the code itself. So the question is this: how will you put your agent in drive🚘?