For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Certified Architect Foundations: The Complete Guide - Part 1

• Claude Certified Architect Foundations: The Complete Guide - Part 2

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

Join 8900+ developers to hear stories from Open source and technology.

Must Read

• Anthropic has released Claude Fable 5 and Mythos 5. Fable 5 brings the Mythos model family to general users, but with stricter safeguards. For safety, some sensitive requests are routed to Claude Opus 4.8 instead. Mythos 5 is for trusted users who need more flexibility in areas like cybersecurity. Check Anthropic’s post for more details.

• Google has released Gemini 3.5 Live Translate. It is a new audio model for live speech to speech translation. It can detect more than 70 languages and translate speech while keeping the speaker’s tone, pace, and pitch. Check Google’s post for more details.

• Kimi has launched Kimi Work, a local desktop AI agent for everyday work. It can connect to your local files and use the browser for tasks. It can also run scheduled tasks and coordinate multiple agents for larger work. Check Kimi’s page for more details.

• Google has released DiffusionGemma. It is an experimental open model built for faster text generation. It uses diffusion method, which creates blocks of content at once instead of going token by token. Google says it can run up to 4x faster on dedicated GPUs. Check Google’s post for more details.

OSS Highlight of the Week

This week we are featuring Herdr. It is a terminal based agent multiplexer for running multiple coding agents. You can organize agents in workspaces, tabs, and panes. It also shows whether agents are blocked, working, or done. It supports detach and reattach, so agents can keep running in the background. Check the GitHub repo for more details.

Share

Good to know

• Anthropic has changed how Claude Code billing works after June 15. If you are not sure whether to use Pro, Max, API credits, or Codex, this pricing breakdown is useful. It explains what is still covered by your Claude plan and what now needs separate credits. Check FindSkill’s post for more details.

• ChatGPT can now generate charts directly inside the chat. You can ask it to turn data or comparisons into simple visuals. The feature is available now on mobile and web. Check ChatGPT’s post for more details.

• If you are trying to learn Agent Harness, this course is a good starting point. It explains why AI coding agents fail and how harnesses make them more reliable. It covers rules, state management, testing, observability, and clean handoffs. Check the Harness Engineering course for more details.

• Loop Engineering is becoming popular for AI coding agents. Instead of prompting agents step by step, the idea is to design loops that guide the work for them. These loops can use automations, worktrees, skills, connectors, subagents, and memory. Check Addy’s post for more details.

Notable FYIs

• Xiaomi has released MiMoCode, an open source AI coding agent for the terminal. It can read and write code, run commands, manage Git, and keep project memory across sessions. It also supports multiple agents, subagents, MCP, and custom model providers. Check the GitHub repo for more details.

• Cohere has released North Mini Code. It is Cohere’s first model built for developers. The open source MoE coding model has 30B total parameters, with 3B active. It is built for agentic software engineering. Check Cohere’s post for more details.

• We all use AI tools and know they can consume a lot of tokens. Headroom is a context compression layer for AI agents. It compresses tool outputs, logs, files, and RAG chunks before they reach the LLM. The repo says it can reduce tokens by 60 to 95 percent. Check the GitHub repo for more details.

• Cognition has introduced FrontierCode, a new benchmark for coding agents. It checks whether AI generated code is good enough to merge into real production codebases. The benchmark looks beyond correctness and checks tests, scope, style, maintainability, and code quality. Check Cognition’s post for more details.

• Apple has introduced Core AI for developers. It lets developers run AI models on Apple silicon. It also includes tools for model preparation, debugging, and inference performance. Check Apple’s documentation for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Certified Architect Foundations: The Complete Guide - Part 1

• Claude Certified Architect Foundations: The Complete Guide - Part 2

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

Join 8900+ developers to hear stories from Open source and technology.

Must Read

• Microsoft AI has launched seven models. The new family covers reasoning, code, image, transcription, and voice. Among them, MAI Thinking 1 is a reasoning model trained from scratch for STEM reasoning and coding tasks. Check Microsoft’s post for more details.

• Hermes Agent now has a native desktop app. It brings Hermes Agent to a simple desktop app, without needing the terminal. Users still get the same agent, memory, and skills. Check the Hermes Desktop page for download details.

• Google has released Gemma 4 12B. It is an open weight model built for agentic workflows. It supports text, vision, and native audio inputs. It is laptop ready and can run locally with 16GB memory. Check Google’s post for more details.

• NVIDIA has released Nemotron 3 Ultra. It is their most capable Nemotron model so far. It supports up to 1M context and gives better control over reasoning during inference. NVIDIA is also releasing the model checkpoints, training datasets, and recipes. Check NVIDIA’s post for more details.

OSS Highlight of the Week

This week we are featuring Cate. It is an infinite zoomable canvas for coding. You can keep your editor, terminal, browser, docs, and AI agents in one workspace. It helps you work on a project without switching between too many windows. Check the GitHub repo for more details.

Good to know

• OpenAI is taking Codex beyond coding. Sites are a new canvas where Codex can turn ideas into dashboards. They also shipped plugins for areas like sales, product design, analytics, and finance. Each plugin brings the needed apps, skills, instructions, and workflows together. Check OpenAI’s Codex post for more details.

• Anthropic released Claude Opus 4.8 last week. Whenever an Opus model gets released, expectations are usually high. Opus 4.8 brings better coding performance, effort control, cheaper Fast mode, and parallel subagents in Claude Code. Check Anthropic’s announcement for more details.

• Meta has introduced Meta Business Agent. It helps businesses handle customer conversations on WhatsApp, Messenger, and Instagram. It can answer questions, suggest products, and book appointments. It uses AI to give more personalized support to customers. Check Meta’s post for more details.

• Cloudflare cofounder Matthew Prince says bot traffic has now crossed human traffic on the internet. He says this happened faster than he expected because agentic traffic is growing quickly. This shows how AI agents are starting to change web traffic. Check the post for more details.

• xAI has rolled out Grok Imagine 1.5 Preview. It is the latest image and video generation model from xAI. It supports up to 2K image output, 10 images per request, and videos up to 15 seconds. Check xAI’s Imagine API page for more details.

Notable FYIs

• Anthropic released dynamic workflows in Claude Code. Claude can now write its own harness on the fly for complex tasks. Since dynamic workflows may use more tokens, it is better to use them only when needed. Check Anthropic’s blog for example prompts and more details.

• Qwen has released Qwen3.7 Plus. It is their latest multimodal agentic model. It is built for agentic tasks like screen understanding, GUI tasks, and browser workflows. It can also navigate mobile apps and complete tasks. Check Qwen’s post for more details.

• MiniMax has released MiniMax M3. It is an open weight model built for coding and agentic tasks. It supports image and video input, computer use, and 1M context. MiniMax says it is the first open weight model to bring all these together. Check MiniMax’s M3 post for more details.

• NVIDIA has released the open weight Cosmos3 model. It is a collection of world models built for Physical AI. It can be used for robotics, autonomous vehicles, and smart spaces. Check the Hugging Face model card for more details.

• Hugging Face has open sourced Trackio. It is a simple alternative to Weights and Biases. You can run it locally and track your experiments without setting up a hosted tool. Check the GitHub repo for more details.

• OpenAI models, Codex, and Managed Agents are now available on AWS. AWS customers can use OpenAI models through Amazon Bedrock. This makes it easier for enterprises to use OpenAI inside their existing AWS setup. Check OpenAI’s post for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

This part covers the remaining domains and how to register for the exam. Here is what we will cover.

1. Prompt Engineering & Structured Output

2. Context Management & Reliability

3. How to register for the exam

I have also added more practice questions to the CCAF GitHub repo. Six sets now, covering all domains.

1. Prompt Engineering & Structured Output

• Explicit Criteria

• Few-shot Prompting

• Structured Output

• Validation-Retry Loops

• Multi-pass Review

• Schema Design

Explicit Criteria

We have to give exact instructions to Claude instead of vague conditions. This is called explicit criteria. Telling Claude like “be careful” or “report high security issues” does not work. Claude does not know what that means in practice.

Tell Claude exactly what to do and what not to do. When you are more specific, Claude makes fewer mistakes.

# Bad — vague, 
system_prompt = """
Review this code and flag any security issues.
Only report high confidence findings.
"""

# Good — categorical, Claude knows exactly what to flag
system_prompt = """
Review this code for security issues.
Flag a finding ONLY when:
- User input is passed directly to a SQL query without parameterization
- A secret or API key is hardcoded as a string literal
- User-supplied data is rendered in HTML without escaping

Do not flag theoretical risks or best practice suggestions.
"""

Few-shot Prompting

Give Claude examples before asking it to do the task. This is called few-shot prompting. Two to four examples is enough. More than that wastes tokens.

One thing to keep in mind. Few-shot prompting is probabilistic. Claude will follow the examples most of the time but not always. If you want something to run without fail, put it in a hook.

system_prompt = """
Extract the customer name and order ID from the message below.

Example 1:
Message: "Hi, I am John and my order 1234 has not arrived."
Output: {"name": "John", "order_id": "1234"}

Example 2:
Message: "This is Sarah. Order #5678 is damaged."
Output: {"name": "Sarah", "order_id": "5678"}

Now extract from this message:
"""

Structured Output

If you ask Claude to “output as JSON” in the prompt, it will try. But it is not guaranteed. The reliable way is to use structured outputs.

Method 1 — JSON outputs

• Define the schema in output_config of the client.messages.create() call.

• Claude returns the answer as JSON text in response.content[0].text.

• Parse it with json.loads() to get the data.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Extract order details from: John's order 1234 is missing"}],
    output_config={ # tells Claude to return structured JSON
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "customer_name": {"type": "string"},
                    "order_id": {"type": "string"},
                    "issue": {"type": "string"}
                },
                "required": ["customer_name", "order_id", "issue"]
            }
        }
    }
)
# Claude returns guaranteed JSON in content[0].text
result = json.loads(response.content[0].text)
# {"customer_name": "John", "order_id": "1234", "issue": "missing"}

Method 2 — Strict tool use

This method is used to pass structured input to your tools with guaranteed schema compliance.

When Claude calls a tool in an agentic workflow, it passes parameters to that tool. Without strict mode, those parameters may not match your schema exactly. With strict: True on the tool definition, Claude is forced to pass parameters that exactly match your input_schema. The structured data Claude fills in is available in block.input on the tool call response.

tools = [{
    "name": "extract_order",
    "description": "Extract order details",
    "strict": True,          # Claude must fill in all fields exactly as defined
    "input_schema": {
        "type": "object",
        "properties": {
            "customer_name": {"type": "string"},
            "order_id": {"type": "string"},
            "issue": {"type": "string"}
        },
        "required": ["customer_name", "order_id", "issue"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "extract_order"},  # force Claude to call this tool
    messages=[{"role": "user", "content": "John's order 1234 is missing"}]
)

for block in response.content:
    if block.type == "tool_use":
        print(block.input)   # structured data Claude filled in
        # {"customer_name": "John", "order_id": "1234", "issue": "missing"}

Validation-Retry Loops

Structured output guarantees the structure. It does not guarantee the values are correct. This is where the validation-retry loop comes in. When Claude returns wrong values, you send the error back with specific details about what went wrong. Claude fixes it and tries again.

MAX_RETRIES = 3
for attempt in range(MAX_RETRIES):
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        tool_choice={"type": "tool", "name": "extract_order"},
        messages=messages
    )

    for block in response.content:
        if block.type == "tool_use":
            result = block.input

            # Validate the result
            if not result.get("order_id").startswith("ORD-"):
                # Send specific error back — not a generic "try again"
                messages.append({"role": "assistant", "content": response.content})
                messages.append({"role": "user", "content": [{
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": "order_id must start with ORD-. You returned: " + result["order_id"]
                }]})
                break  # go to next attempt

            return result  # valid — done

raise RuntimeError("Failed to get valid output after max retries")

Always send specific error details. Tell Claude which field failed and what you expected. A generic "try again" does not give Claude enough context to fix the issue.

Retry loops fix format errors. But if the data is simply not there in the source, retrying will not help. Claude cannot return something that does not exist.

Multi-pass Review

When Claude generates something and then reviews it in the same session, it already knows how it was built. It will miss its own mistakes. That is the problem with self-review.

Multi-pass review fixes this. You use a separate Claude session to review the output. The reviewer session has no memory of how the output was generated. It looks at the result with fresh eyes.

# Pass 1 — generate the code
generation_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Write a FastAPI endpoint for processing refunds"}]
)
generated_code = generation_response.content[0].text

# Pass 2 — review in a separate session
review_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": f"Review this code for security vulnerabilities:\n\n{generated_code}"}]
)

Never use the same session for generation and review. Always use a separate session.

Schema Design

When you define a JSON schema for structured output, each field tells Claude what to extract and in what format. One of those fields can be an enum. It is a fixed list of allowed values. For example, if you have an issue field you can restrict it to "missing", "damaged", or "wrong_item", you define it as an enum. Claude can only pick from that list.

Three things to know in Schema Design:

Enums - always add "other" to the list. If Claude sees something that does not fit any of the defined values, it will pick the closest one instead of telling you it does not know. With "other" in the list, Claude has a safe option to fall back to.

Nullable fields — if a field may not always be present, use ["string", "null"] instead of "string". Never mark optional fields as required. Claude will make up a value just to fill it.

Flat structures — avoid deeply nested objects in your schema. Deep nesting makes it harder for Claude to fill the schema accurately. Keep your schema flat. If the data is complex, split it across multiple tool calls.

tools = [{
    "name": "extract_order",
    "description": """Extract order details. Issue must be one of: missing, damaged, wrong_item, other.
    Use other when the issue does not fit the above categories.""",
    "strict": True,  # Claude must follow the schema exactly
    "input_schema": {
        "type": "object",
        "additionalProperties": False,  # no extra fields allowed
        "properties": {
            "customer_name": {"type": "string"},
            "order_id": {"type": "string"},
            # issue must be a string 
            # issue can only be one of these four values — always include "other" in enum.
            "issue": {
                "type": "string",
                "enum": ["missing", "damaged", "wrong_item", "other"]
            },
            # fill this when issue is "other" — gives Claude somewhere to put unexpected values
            "issue_detail": {"type": "string"},
            # nullable — Claude returns null when delivery date is not mentioned in the source
            "delivery_date": {"type": ["string", "null"]}
        },
        # only these fields are required — issue_detail and delivery_date are optional
        "required": ["customer_name", "order_id", "issue"]
    }
}]

2. Context Management & Reliability

This domain carries 15% of your exam score. It is the smallest domain. But it matters. If you do not manage context well, your agents become unreliable in production.

Below are the key concepts.

• Lost-in-the-Middle Effect

• Progressive Summarization

• Tool Result Trimming

• Escalation and Ambiguity

• Error Propagation

• Prompt Caching

• Message Batches API

Lost-in-the-Middle Effect

Claude can process up to 1 million tokens in a single request. But more context does not always mean better results.

When you pass a long input, Claude processes the beginning and end reliably. What is in the middle often gets missed. This is called the lost-in-the-middle effect.

Two things to know

• Place critical information at the beginning or end. Never place it in the middle.

• For large context tasks, delegate to subagents. Each subagent starts fresh with only what it needs.

Progressive Summarization

As an agent runs through multiple turns, the conversation history keeps growing. At some point it gets too large to pass in full on every API call.

Progressive summarization solves this. Instead of passing everything, you summarize the older turns and keep only the recent ones in full. The summary replaces the old turns in the messages array.

# When history gets too long, summarize older turns
summary_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": f"Summarize this conversation history into key facts only:\n\n{old_turns}"
    }]
)

summary = summary_response.content[0].text

# Replace old turns with the summary
messages = [
    {"role": "user", "content": f"Previous context: {summary}"},
    *recent_turns  # keep the last few turns in full
]

When we summarize, we may lose details. Dates, percentages, and numeric values often become vague. If you want anything to stay precise, extract it into a structured state object before summarizing.

Tool Result Trimming

Every tool call adds output to the context. If a tool returns 40 fields but you only need 5, the remaining 35 are wasting tokens. Over multiple turns this adds up fast and fills your context with noise.

Trim tool results before appending them to the next API messages array. Always keep your context clean. Pass only what Claude needs. Learn more about managing tool context here.

# Bad — full tool result, 40+ fields appended to messages
result = get_customer(customer_id="C-42")
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": block.id,
        "content": json.dumps(result)
    }]
})

# Good — trim before appending, only what Claude needs
result = get_customer(customer_id="C-42")
trimmed = {
    "id": result["id"],
    "name": result["name"],
    "status": result["status"]
}
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": block.id,
        "content": json.dumps(trimmed)
    }]
})

Escalation and Ambiguity

Not every task should be handled autonomously. Knowing when to escalate to a human is just as important as knowing how to complete a task.

Three valid reasons to escalate:

• When the user explicitly requests a human, escalate immediately. Do not attempt to investigate first.

• When the agent does not have clear instructions for the situation, escalate. Do not guess.

• When the agent cannot make meaningful progress, escalate.

When a tool returns multiple matching results, ask the user for more details to narrow it down. Never pick one based on a guess.

# Tool returns escalation signal
@mcp.tool()
def process_refund(order_id: str, amount: float) -> dict:
    if amount > 500:
        return {"requires_human": True, "reason": "Refund above $500 needs approval"}
    return {"success": True, "refund_id": "REF-001"}

# Agent loop checks for it
result = tool_map[block.name](**block.input)

if result.get("requires_human"):
    escalate_to_human(result)
    return

Two common mistakes to avoid.

Do not escalate just because the user seems frustrated. Frustration does not mean the task needs human intervention. Acknowledge it, try to resolve it, and only escalate if the user explicitly asks for a human.

Do not use the agent’s own confidence score as an escalation signal. Models tend to be overconfident even when they are wrong. It is not reliable.

Error Propagation

In a multi-agent system, when a subagent fails, the coordinator needs to know what went wrong. If the subagent returns a generic error, the coordinator cannot decide what to do next.

Subagents should always return structured error context. Not a generic failure status.

# Bad — coordinator has no idea what went wrong
return {"error": True}

# Good — coordinator knows what failed and what to do next
return {
    "error": True,
    "type": "tool_failure",
    "tool": "lookup_order",
    "reason": "Order not found in database",
    "retryable": False
}

Never suppress errors silently. If a subagent fails without sending a signal, the coordinator assumes success and moves on. That produces wrong results in the next steps.

Not all errors are the same. A timeout can be retried. A missing record cannot be retried. Tell the coordinator what went wrong so it can decide what to do.

Also remember, subagents do not share context automatically. If one fails, the coordinator has to pass that information forward explicitly.

Prompt Caching

Every time you call the Claude API, you send the full context. You send system prompt, conversation history, tool definitions. Claude processes all of it from scratch on every single call. That adds up fast. It becomes more tokens with higher cost.

With prompt caching we can reduce the cost. You mark the static parts of your prompt with cache_control. Claude caches them on the first call. Instead of paying full price on every call, you pay only 10% for the tokens that are already cached.

There are two ways to enable it.

Automatic caching - You just add cache_control at the top level of your request. Claude scans your prompt from top to bottom and places the cache breakpoint at the end of the last block that can be cached, which is typically the end of your system prompt or tool definitions.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    cache_control={"type": "ephemeral"},  # automatic — Claude picks the breakpoint
    system="You are a customer support agent.................  ",
    messages=[{"role": "user", "content": user_query}]
)

Explicit caching - you mark specific content blocks with cache_control directly inside the system array. Claude caches everything before and up to that block. Use this when you want to control exactly where the cache ends.

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {"type": "text", "text": "You are a customer support agent."},
        {
            "type": "text",
            "text": large_document,
            "cache_control": {"type": "ephemeral"}  # cache everything up to here
        }
    ],
    messages=[{"role": "user", "content": user_query}]
)

Always cache static content only. You can put system prompts, tool definitions, and large documents in cache. Never put dynamic content in cache.

Every API call checks whether the cached prefix matches exactly. Even a single character difference causes a cache miss and Claude reprocesses everything from scratch.

TTL and pricing

TTL stands for Time to Live. It is how long the cache stays active. By default the cache expires after 5 minutes. Every cache hit resets the timer. If your requests come in less frequently, you can extend the TTL to 1 hour at 2x the cache write price.

• The first call writes to cache and costs 1.25x normal input tokens.

• Cache read costs 0.1x normal input tokens.

• You can place a maximum of 4 cache_control breakpoints in a single request.

• If you use the Batch API and prompt caching together, both discounts apply.

• The first call costs more because it writes to cache. From the 4th read onwards you start saving money.

To check if caching is working, look at the response usage.

print(response.usage.cache_read_input_tokens)     # tokens read from cache
print(response.usage.cache_creation_input_tokens)  # tokens written to cache

If cache_read_input_tokens is greater than 0, the cache was hit.

Message Batches API

When you need to process a large number of API requests without needing an immediate response, use the Message Batches API. For example, processing thousands of customer feedback forms overnight, or doing bulk content generation.

You can submit up to 100,000 requests in one batch. Claude processes them asynchronously. Most batches finish within 1 hour, but they can run up to 24 hours. If they do not complete within 24 hours, they expire.

The cost is 50% off standard API pricing. The output quality is the same. Only the timing is different.

import anthropic
import time

client = anthropic.Anthropic()

# Create a batch with multiple independent requests
batch = client.messages.batches.create(
    requests=[
        {
            # This custom id will be returned with the result, 
            # so we know this output is for feedback_001
            "custom_id": "feedback_001",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 500,
                "system": "You are a support analyst. Summarize customer feedback in 2 short bullet points.",
                "messages": [
                    {
                        "role": "user",
                        "content": "The app is useful, but the login takes too much time."
                    }]
            }},
        {
            # This custom id will be returned with the result
            # so we know this output is for feedback_002
            "custom_id": "feedback_002",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 500,
                "system": "You are a support analyst. Summarize customer feedback in 2 short bullet points.",
                "messages": [
                    {
                        "role": "user",
                        "content": "The dashboard is clean, but export to PDF is missing."
                    }]
            }}
    ])

print(f"Batch ID: {batch.id}")

# Wait until the batch completes
while True:
    current_batch = client.messages.batches.retrieve(batch.id)

    if current_batch.processing_status == "ended":
        break

    time.sleep(30)

# Read the results
for result in client.messages.batches.results(batch.id):
    if result.result.type == "succeeded":
        print(f"{result.custom_id}: {result.result.message.content[0].text}")

    elif result.result.type == "errored":
        print(f"Error in {result.custom_id}: {result.result.error}")

    elif result.result.type == "canceled":
        print(f"Canceled: {result.custom_id}")

    elif result.result.type == "expired":
        print(f"Expired: {result.custom_id}")

Three things to know.

• Use custom_id to tie each result back to your input. Without it you cannot match results to requests.

• You can combine the Batch API with prompt caching. Both discounts apply together, so if your requests share the same system prompt, use both for maximum savings.

• Use the Batch API for async workloads only. If you need a real-time response, use the standard Messages API.

3. How to Register for the exam

The exam is currently available to employees of companies in the Anthropic Partner Network. The Partner Network is free to join. Any company building with Claude qualifies for it.

Step 1 — Join the Partner Network

Your company needs to be part of the Anthropic Partner Network. If you are not in the partner network then apply for Claude Partner Network.

Step 2 — Request exam access

If you are already in the partner network, then login to the network and take up the exam.

Step 3 — About exam

60 questions. 120 minutes. No notes, no AI tools, no external resources are allowed.

Free prep resources

Free resources are available on Anthropic Academy and open to everyone. Start there regardless of whether you have exam access yet.

Certificate validity

The certificate is valid for 6 months. After that you need to recertify.

Conclusion

I hope this gave you a clear picture of what the exam covers. We went through all the domains across both parts.

I have also added 6 sets of practice questions to the GitHub repo.

These concepts are not just for the exam. Knowing them well will make you a better engineer when building with Claude.

Happy Learning!

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Certified Architect Foundations: The Complete Guide - Part 1

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Google DeepMind has introduced AI Pointer. You can point to something on your screen and ask Gemini to act on it. It understands what you are pointing at, so you don’t need long prompts. It also supports voice, text, and images. Check Google DeepMind’s post for more details.

• OpenAI has brought Codex to the ChatGPT mobile app. You can track tasks, review outputs, and guide Codex from your phone. Your files and credentials stay on the machine where Codex is running, while updates come to your phone in real time. Check OpenAI’s post for more details.

• OpenClaw’s Peekaboo is worth checking if you are exploring screen based agents. It helps AI agents capture screens, understand what is on them, and automate GUI actions. It works as both a CLI and MCP server for Codex, Claude Code, and Cursor. Check the Peekaboo GitHub repo for more details.

• Thinking Machines Lab has introduced interaction models. The idea is to make AI conversations feel more natural and live. The interesting part is the architecture. One model stays responsive during the live conversation, while a background model handles reasoning, search, and tool use. Check Thinking Machines Lab’s post for more details.

OSS Highlight of the Week

This week we are featuring Flue. It is an agent harness framework for building headless and programmable agents. Think of it like Claude Code, but without the terminal UI or human operator. It supports sandboxes, sessions, skills, MCP tools, and deployment across runtimes. Check the Flue GitHub repo for more details.

Share

Good to know

• Claude Code now supports /goal. You can give a task with a clear goal. Claude will keep working until that goal is done. A small evaluator model checks the progress after each turn. Check Claude Code docs for more details.

• Claude Platform is now available directly on AWS. AWS customers can now use more Claude capabilities, beyond Bedrock models. It includes Claude Managed Agents, code execution, web search, Skills, MCP, and more. Check Claude’s post for more details.

• OpenAI has introduced Daybreak for cybersecurity. It brings GPT 5.5 and Codex Security into security workflows. It helps teams review code, find risks, validate patches, and fix issues faster. The goal is to bring AI earlier into secure software development. Check OpenAI’s Daybreak page for details.

• I came across Thariq’s post on using HTML instead of Markdown for agent outputs. Markdown works well for simple notes, but large outputs can become hard to read. HTML can show the same content with better visuals and richer information. His collection has 20 HTML examples generated by agents. Check the post and collection for more details.

Notable FYIs

• Google has released Agent Skills for Google products. It includes skills for BigQuery, Cloud Run, Firebase, GKE, and more. It also covers Google Cloud onboarding, authentication, and network observability. Check the Google Skills GitHub repo for more details.

• If you are using AI coding agents and want to know where your tokens are going, check CodeBurn. It shows usage across Claude Code, Codex, and Cursor. It also breaks usage down by task, tool, model, and project. You also get an interactive terminal dashboard for cost visibility. Check the CodeBurn GitHub repo for more details.

• xAI has released Grok Build. It is a coding agent that runs from the terminal. It comes with familiar coding agent features like plans, skills, plugins, hooks, and parallel subagents. Check xAI’s Grok Build page for more details.

• Claude Code now has Agent View. It helps you manage many Claude Code sessions from one place. You can see which agents need input, which are still working, and which are done. It is useful if you run multiple coding agents in parallel. Check Claude’s blog for more details.

• Mirage is a virtual filesystem for AI agents. It gives agents one common way to access tools like S3, Google Drive, Slack, Gmail, and more. Agents can use simple file commands instead of separate APIs. Check the Mirage GitHub repo for more details.

• Higgsfield has released Supercomputer. It is an AI agent for creating ads, product shots, marketing content, and campaigns. You can describe what you want, and it picks the right model for the task and gets the work done. Check Higgsfield’s post for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Certified Architect Foundations: The Complete Guide - Part 1

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Anthropic has signed a compute deal with SpaceX. This will increase Claude’s compute capacity. Because of this, Claude Code’s five hour limits are now doubled for paid tiers. Peak hour limit reductions are also removed. Check Anthropic’s announcement for more details.

• OpenAI has released GPT 5.5 Instant as ChatGPT’s new default model. It is also available in the API. OpenAI says it gives smarter, more accurate, and clearer answers based on your context. Check OpenAI’s announcement for more details.

• We have already seen models with 1M context windows. But SubQ has introduced a model built for 12M token reasoning. It is designed to work across full repos and long context tasks. SubQ says it runs at one fifth the cost of leading LLMs. Check SubQ’s post to know how this model works.

• Claude and Perplexity are moving deeper into finance workflows. Claude has introduced finance agent templates. Perplexity has launched Perplexity Computer for Finance. Both show how AI tools are moving from general chat to specific business work. Check their posts for more details.

OSS Highlight of the Week

This week we are featuring Deepsec. It is an open source security harness from Vercel Labs. It uses coding agents to find vulnerabilities in your codebase. It can scan large repos, investigate issues, and generate findings with recommendations. Check the GitHub repo if you want to try agent based security scanning.

Good to know

• Eugene Yan has written a practical post on working better with AI. He talks about giving better context, saving your preferences into config, and making output verification easier. Useful if you use AI for writing, coding, or daily work. Check Eugene’s post for more details.

• Paper Copilot is a useful site for AI and ML papers. It brings papers from different conferences into one place and makes them easier to explore. Useful if you want to track new research without jumping across many sites. Check Paper Copilot for more details.

• Editframe has launched Agent Skills for video. This skill helps coding agents create videos from simple prompts. You can use it with Claude Code, Cursor, or Codex. It can generate a working video or a full interactive GUI from your prompt. Check the Editframe post for more details.

• Inworld has released Realtime TTS 2. It is built for realtime voice conversations. It understands the full audio context, including tone, pacing, and emotional state. Check Inworld’s post for more details.

• SpAItial has released Echo 2 for 3D world generation. It can take text or image input and create a 3D world that can be explored in real time. This can be useful for games, digital twins, architecture, and robotics simulation. Check SpAItial’s post for more details.

Notable FYIs

• OpenAI has released three new audio models in the API. GPT Realtime 2 brings GPT 5 class reasoning to voice apps. GPT Realtime Translate supports live speech translation, and GPT Realtime Whisper supports live transcription as someone speaks. Check OpenAI’s announcement for more details.

• Last time we covered Claude Managed Agents. Now Anthropic has added more features to Claude Managed Agents. It includes dreaming, outcomes, webhooks, and multiagent orchestration. Dreaming reviews past work and improves memory over time. Outcomes checks whether the work meets the expected result. Check Anthropic’s announcement for more details.

• xAI has introduced Custom Voices and Voice Library for Grok. Developers can create their own voice and use it in Grok’s TTS and Voice Agent APIs. Teams can also browse, preview, and manage voices from the xAI console. Check xAI’s announcement for more details.

• Xiaomi has open sourced MiMo V2.5 Pro. It is built for agentic coding, long horizon tasks, and large context work. Xiaomi says it can handle complex workflows with many tool calls and a 1M token context window. Check Xiaomi’s post for more details.

• Anthropic has released Claude Security for Claude Enterprise customers. It scans code for vulnerabilities and uses Opus 4.7 to generate proposed fixes. It also supports scheduled scans, targeted scans, triage tracking, and exports for audit workflows. Check Claude’s announcement for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

I have been building agentic systems with Claude for a long time. When I heard about the exam, I wanted to understand what it actually tests.

So I went through the entire exam guide, also took some mock tests to understand what they covered.

Below are the sections you need to understand to become a Claude Certified Architect.

1. Agentic Architecture & Orchestration

2. Tool Design & MCP Integration

3. Claude Code Configuration

4. Prompt Engineering & Structured Output

5. Context & Reliability

Each section is detailed enough to be its own blog. We will cover the first three in this part. The remaining sections along with how to register will be in Part 2.

I have also put together a set of practice questions with answers on GitHub. I will keep adding more as I come across them.

1. Agentic Architecture & Orchestration

This section carries 27% of your exam score. It covers Claude Agent SDK, the library you use to build production grade agents. Below are the key Agent SDK concepts, that turn a normal LLM into an agent.

• stop_reason

• Conversation History

• Loop Termination

• Multi-Agent Systems

• Task Decomposition

• Hooks

• Session Management

A normal LLM call is simple. You send a message, Claude replies, done. An agent is different. It is multiple LLM calls chained together until the task is fully complete. It includes tool calling, getting results, and deciding what to do next.

Let us start with stop_reason. It is the core of every agent loop.

stop_reason

Every Claude API response has a field called stop_reason. It tells you why Claude stopped. This is what decides whether your loop continues or ends. stop_reason has multiple values. The three you need to know for the exam are,

If stop_reason == "tool_use" then it means Claude wants to call a tool. Then you execute the tool, append the result, and loop again.

If stop_reason == "end_turn" then Claude is done. We can return the response to the user. Loop ends.

If stop_reason == "max_tokens" then the response got cut off. This happens when Claude hits the max_tokens limit you set in the API call.

If the response genuinely needs more tokens, increase max_tokens. If the response is too verbose, then restructure your prompt to produce a shorter output. Never return a cut-off response as it is incomplete.

Here is the stop_reason with all three options, explained in code.

import anthropic
import json

client = anthropic.Anthropic()

class Agent:
    def __init__(self, tools):
        self.tools = tools

    def run(self, task: str) -> str:
        # Every conversation starts with the user task
        messages = [{"role": "user", "content": task}]

        while True:
            # Claude does not remember previous call, 
            # So we pass the full conversation history every time
            response = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                tools=self.tools,
                messages=messages
            )

            # Check the stop_reason to ensure the Task is complete
            if response.stop_reason == "end_turn":
                return extract_text(response.content)
            
            # If stop_reason is tool_use then execute the tool
            elif response.stop_reason == "tool_use":

                # Step 1 — save what Claude said, including which tool it wants to call
                messages.append({
                    "role": "assistant",
                    "content": response.content
                })

                for block in response.content:
                    if block.type == "tool_use":

                        # Step 2 — we execute the tool, not Claude
                        result = tool_map[block.name](**block.input)

                        # Step 3 — send the tool result back so Claude can continue
                        # tool_use_id tells Claude which tool call this result belongs to
                        messages.append({
                            "role": "user",
                            "content": [{
                                "type": "tool_result",
                                "tool_use_id": block.id,
                                "content": json.dumps(result)
                            }]
                        })
                # Claude now sees the result and decides what to do next

            else:
                # stop_reason == "max_tokens" — response was cut off, never return incomplete results
                raise RuntimeError(f"Unexpected: {response.stop_reason}")

The loop runs until Claude returns end_turn.

Handling stop_reason is one of the most important concepts in agentic workflows. Learn more in the official docs.

Now that you understand stop_reason, let us look at how Claude keeps track of everything that happens in the loop.

Conversation History

In agentic workflows, Claude has no memory between API calls. Every time you call the API, you have to pass the full conversation history. That is how Claude knows what happened before.

The messages array holds that history. User messages, Claude responses, and tool results all get appended here until the task is done.

So how does the messages array grow? Every time stop_reason == "tool_use", you append two things.

First, you append the response Claude just sent. This contains the tool name Claude wants to call and the input values it decided to pass.

messages.append({
    "role": "assistant",
    "content": response.content    # text block + tool_use block
})

Then you execute the tool and append the result back. The tool_use_id in the result must match the one from the response we appended previously. This tells Claude that this result is for the tool call it requested.

Now you loop again. Claude reads everything in the messages array and decides what to do next.

for block in response.content:
    if block.type == "tool_use":
        result = tool_map[block.name](**block.input)

        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            }]
        })

Do not add text immediately after tool results. Send tool results directly without additional text

Loop Termination

An agent loop can terminate for different reasons. We need to identify each termination reason and handle it. If we do not, the agent either runs forever, returns incomplete results, or takes actions it should not.

Here are the three ways we handle it.

• stop_reason == "end_turn" - Claude is done. Return the response to the user and exit the loop.

• result.get("requires_human") == True - escalate to a human and exit the loop.

• MAX_ITERATIONS = 10 - the loop hit the safety cap. Raise an error and exit.

In all three cases, we handle the termination and never return incomplete results. Here is how all three work together in code.

MAX_ITERATIONS = 10

def escalate_to_human(result: dict) -> None:
    # Notify your human review system — ticket, Slack, email etc.
    print(f"Escalating to human: {result}")

def extract_text(content) -> str:
    # Extract the text block from Claude's response
    for block in content:
        if hasattr(block, "text"):
            return block.text

class Agent:
    def __init__(self, tools):
        self.tools = tools

    def run(self, task: str) -> str:
        # Every conversation starts with the user task
        messages = [{"role": "user", "content": task}]

        for i in range(MAX_ITERATIONS):
            # Claude does not remember previous calls
            # So we pass the full conversation history every time
            response = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                tools=self.tools,
                messages=messages
            )

            # Claude is done — return the response to the user
            if response.stop_reason == "end_turn":
                return extract_text(response.content)

            elif response.stop_reason == "tool_use":
                # Append Claude's response to history
                messages.append({
                    "role": "assistant",
                    "content": response.content
                })

                for block in response.content:
                    if block.type == "tool_use":
                        # we execute the tool
                        result = tool_map[block.name](**block.input)

                        # Tool requires human intervention — escalate and exit the loop
                        if result.get("requires_human"):
                            escalate_to_human(result)
                            return

                        # Append tool result so Claude can continue
                        messages.append({
                            "role": "user",
                            "content": [{
                                "type": "tool_result",
                                "tool_use_id": block.id,
                                "content": json.dumps(result)
                            }]
                        })

        # Max iterations reached — exit with error, never return incomplete results
        raise RuntimeError("Agent hit max iterations without completing")

Multi-Agent Systems

You now know how a single agent works. But some tasks are too complex for one agent to handle alone.

That is where multi-agent systems come in. You break the work across multiple specialized agents. Each one is the same Agent class we defined in the previous sections, just with different tools and a different responsibility.

search_agent = Agent(tools=[web_search_tool])
analysis_agent = Agent(tools=[analysis_tool])
report_agent = Agent(tools=[report_tool])

Anthropic uses a pattern called hub-and-spoke to coordinate agents. Think of it like this. One coordinator receives the task, breaks it down, and delegates to specialized agents. Each agent does its part and reports back. The coordinator collects everything and produces the final response.

Now, when do you run agents in parallel and when in sequence?

If the tasks are independent, run them in parallel. If one task needs the output of another, run them in sequence.

import asyncio

# Step 1 — Independent subagents, run in parallel
search_result, document_result = await asyncio.gather(
    search_agent.run("Search web for competitors"),
    analysis_agent.run("Analyze our internal documents")
)

# Step 2 — This subagent depends on Step 1, runs after
report_result = report_agent.run("Generate report", search_result, document_result)

# Step 3 — Coordinator collects all results and produces the final response
final_result = coordinator_agent.run("Finalize", search_result, document_result, report_result)

Every subagent starts with a fresh context. It does not have access to the coordinator's conversation history. The only way to pass context to a subagent is through its prompt. So be specific and detailed in what you pass.

# Too vague — subagent does not know enough to do its job well
search_agent.run("Search web for competitors.")

# Right — give the subagent exactly what it needs
search_agent.run("Search web for competitors in the B2B SaaS space. Focus on pricing and features.")

Agents never talk directly to the user. They always report back to the coordinator. The coordinator owns the task from start to finish.

Task Decomposition

Task decomposition is an important part of building multi-agent systems. When you build one, remember that your coordinator agent should never delegate a vague task directly to a subagent.

Take this for example. Your coordinator receives “Research the competitive landscape for our project management tool.” If it passes this directly to a subagent, the subagent does not know where to start. You will get different results every run.

Break it down first.

• Search Google for “Notion vs Linear pricing plans 2026”

• Extract pricing tiers, feature limits, and target user segments for both

• Generate a comparison table showing where your product has an advantage

Each subtask goes to one specialized agent. Each agent has one job and knows exactly what to return.

The agents are not the problem. Vague instructions are.

Hooks

When you build an agent, some actions need to be controlled programmatically. You cannot rely on Claude to always follow prompt instructions. That is where hooks come in.

Hooks are callback functions you register in the Claude Agent SDK. They fire automatically at specific points during agent execution. No prompts involved.

Two hooks you need to know for the exam,

PreToolUse :

It fires before a tool executes. Since it runs before, it can block the action. Use it when you want to stop Claude from doing something like blocking rm -rf commands, preventing writes to .env, or requiring human approval before processing a refund above $500.

PostToolUse :

PostToolUse fires after a tool executes. It cannot block anything since the action already happened. Use it for things like auto-formatting a file after Claude edits it, writing to an audit log after a deletion, or running a linter after every code change.

Here is a real example. Your agent has a process_refund tool. Any refund above $500 needs human approval before it goes through.

from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient, HookMatcher

async def block_large_refunds(input_data, tool_use_id, context):
    tool_name = input_data["tool_name"]
    tool_input = input_data["tool_input"]

    # Only intercept the process_refund tool
    if tool_name != "process_refund":
        return {}  # allow all other tools to proceed

    # Block refunds above $500 — requires human approval
    if tool_input.get("amount", 0) > 500:
        return {
            "hookSpecificOutput": {
                "hookEventName": input_data["hook_event_name"],
                # deny stops the tool from executing
                "permissionDecision": "deny",
                # this reason is sent back to Claude so it knows why it was blocked
                "permissionDecisionReason": "Refunds above $500 require human approval"
            }
        }

    # Allow refunds under $500 to proceed normally
    return {}

options = ClaudeAgentOptions(
    hooks={
        # PreToolUse fires before the tool executes
        "PreToolUse": [
            # matcher tells the SDK which tool to intercept
            HookMatcher(matcher="process_refund", hooks=[block_large_refunds])
        ]
    }
)

async with ClaudeSDKClient(options=options) as client:
    await client.query("Process a $600 refund for order ORD-999")
    async for message in client.receive_response():
        print(message)

The key difference between hooks and prompt instructions is reliability. A prompt instruction like “never process refunds above $500” is not guaranteed. Claude may follow it or not. A hook always fires. If you want something enforced without exception, put it in a hook.

Session Management

A session contains the full conversation history. The SDK saves it to disk automatically so you can come back to it later.

Here is what you need to know.

• Session Resumption

• Session Isolation

• Session Forking

Session Resumption

Imagine your agent is halfway through a long task and the server crashes. Without session resumption, it starts from scratch. With it, you pass the session ID and the agent continues from where it stopped.

Here is how you implement it.

from claude_agent_sdk import ClaudeAgentOptions, query, ResultMessage

# Start a session and save the session ID
session_id = None
async for message in query("Analyze the refund flow in our codebase"):
    if isinstance(message, ResultMessage):
        session_id = message.session_id

# Resume later — agent has full context from before
async for message in query(
    prompt="Now fix the bug you found",
    options=ClaudeAgentOptions(
        resume=session_id,
        allowed_tools=["Read", "Edit", "Write", "Glob", "Grep"],
    ),
):
    if isinstance(message, ResultMessage) and message.subtype == "success":
        print(message.result)

Session Isolation

Each user or task gets its own session. If two users share the same session, Claude will mix up their context and produce wrong results. Always create a new session for each user or task.

Session Forking

Sometimes you want to try a different approach from where you are, without affecting your current session. For example, your agent has analyzed a codebase and you want to try both a REST and a GraphQL implementation. Instead of starting over, you fork the session. Both forks start from the same point. The original stays untouched.

from claude_agent_sdk import ClaudeAgentOptions, query

# Fork — original session stays unchanged
options = ClaudeAgentOptions(
    resume=session_id,
    fork_session=True   # new session ID, same history
)

async for message in query("Try a GraphQL approach instead", options=options):
    print(message)

To learn more about working with sessions, check out the Claude Agent SDK session guide.

2. Tool Design & MCP Integration

MCP stands for Model Context Protocol. It is an open standard for connecting your agent to external services. For example, your agent can query a database, fetch GitHub issues, or send a Slack message through an MCP server.

If you are new to MCP, check out our complete MCP Server Guide that covers everything from scratch.

Below are the key concepts.

• MCP Components

• Tool Descriptions

• Structured Error Responses

• Tool Distribution

• MCP Server Configuration

MCP Components

An MCP server consists of three things.

• Tools are functions exposed by the MCP server. When Claude calls a tool, the MCP server executes that function. Claude decides when to call the tool and what input to send.

• Resources are read only data exposed by the MCP server. They give Claude extra context for the task. For example, a resource can be an API spec, database schema, product catalog, or project document.

• Prompts are reusable instructions exposed by the MCP server. They tell Claude how to handle a repeated task. In supported clients, prompts can also be triggered as slash commands.

Here is a simple MCP server example. This one connects to PostgreSQL and shows all three components.

from mcp.server.fastmcp import FastMCP
import psycopg2
import os

mcp = FastMCP("DatabaseServer")

# Connect to PostgreSQL — use environment variables for credentials
conn = psycopg2.connect(
    host=os.getenv("DB_HOST"),
    database=os.getenv("DB_NAME"),
    user=os.getenv("DB_USER"),
    password=os.getenv("DB_PASSWORD")
)

# Tool — model calls this to query the database
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Look up an order by order ID from the database."""
    cursor = conn.cursor()
    cursor.execute("SELECT id, status, item FROM orders WHERE id = %s", (order_id,))
    row = cursor.fetchone()
    
    if not row:
        return {"error": "Order not found"}
    
    return {"id": row[0], "status": row[1], "item": row[2]}

# Resource — exposes the full product catalog from the database
@mcp.resource("data://product-catalog")
def get_product_catalog() -> str:
    """Returns all products from the database."""
    cursor = conn.cursor()
    cursor.execute("SELECT name, price FROM products")
    rows = cursor.fetchall()
    return "\n".join([f"{row[0]} - ${row[1]}" for row in rows])

# Prompt — can appear as a slash command in supported clients
@mcp.prompt()
def review_order_prompt() -> str:
    """Template for reviewing an order status."""
    return """You are an order review specialist. 
When reviewing an order:
- Check the current status
- Identify any issues
- Suggest next steps"""

if __name__ == "__main__":
    mcp.run()

Once this MCP server is running and connected to your agent, you can query it directly.

“What is the status of order ORD-999?”

The agent calls the get_order tool, queries the database in real time, and returns the result.

Tool Descriptions

When Claude has multiple tools, it uses the tool description to decide which one to call. If the description is vague, Claude may pick the wrong tool.

A good tool description should clearly say three things.

• What the tool does

• What input it expects

• When to use it and when not to

# Bad — too vague, Claude cannot differentiate
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Retrieves order details."""
    ...

# Good — clear boundaries, Claude knows exactly when to use it
@mcp.tool()
def get_order(order_id: str) -> dict:
    """Look up an order by order ID. 
    Use this when you need order status, items, and shipping details. 
    Do not use this for customer account lookups."""
    ...

Structured Error Responses

When a tool fails, do not return a generic error. Claude needs to know what went wrong so it can decide what to do next.

In production, return more than just an error. Tell Claude what went wrong, whether it can retry, and what to do next.

Here are a few common categories.

• Transient - If the external service is down or timed out, we return the error as transient. It means the failure is temporary and usually safe to retry.

• Validation - If the input is missing or invalid, we return the error as validation. It means Claude should fix the input before calling the tool again.

• Business - If the tool runs, but the action is not allowed by your system rules, we return the error as business. It means there is no point retrying the same request.

• Permission - If the user or agent does not have access to perform the action, we return the error as permission. It means access should be granted first before retrying.

@mcp.tool()
def process_refund(order_id: str, amount: float) -> dict:
    """Process a refund for a given order."""

    # validation — bad input, no point retrying
    if not order_id:
        return {"error": True, "errorCategory": "validation", "isRetryable": False, "message": "order_id is required"}

    # business — order is not eligible for refund, refund window has expired
    if order_status == "delivered_over_30_days":
        return {"error": True, "errorCategory": "business", "isRetryable": False, "message": "Refund window has expired. Orders can only be refunded within 30 days of delivery."}
    
    # transient — service down, safe to retry
    if not payment_service.is_available():
        return {"error": True, "errorCategory": "transient", "isRetryable": True, "message": "Payment service unavailable. Try again."}

    return {"success": True, "refundId": "REF-001"}

Never return a generic error like {"error": "Operation failed"}. The more context you give Claude, the better it recovers.

Tool Distribution

Give each agent only the tools it really needs. Too many tools can confuse Claude. It may call the wrong tool or take the wrong action.

# Bad — agent has access to tools it should never use
research_agent = Agent(tools=[
    web_search_tool,
    process_refund_tool,    # research agent should never process refunds
    delete_record_tool,     # research agent should never delete records
    synthesis_tool
])

# Good — agent only gets what it needs
research_agent = Agent(tools=[
    web_search_tool,
    synthesis_tool
])

Use allowed_tools and disallowed_tools in the Claude Agent SDK to control which tools each agent can access.

options = ClaudeAgentOptions(
    mcp_servers={"orders": order_server},
    allowed_tools=[
        "mcp__orders__get_order",       # pre-approve read operations
        "mcp__orders__get_customer"
    ],
    disallowed_tools=[
        "mcp__orders__delete_record",   # block delete operations
        "mcp__orders__update_record"    # block write operations
    ]
)

To learn more, check the official SDK reference.

MCP Server Configuration

When you add an MCP server to your project, you need to decide where to configure it. There are two scopes.

• Project level — .mcp.json in your repo. It can be shared with the whole team via version control.

• User level — ~/.claude.json. It is personal and experimental. It is not shared.

// .mcp.json — project level, committed to the repo
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"  // never hardcode secrets
      }
    },
    "database": {
      "command": "python",
      "args": ["./mcp_servers/database_server.py"],
      "env": {
        "DB_URL": "${DATABASE_URL}"
      }
    }
  }
}

Use existing community MCP servers for standard integrations like GitHub, Slack, and Jira. Build custom servers only for internal or team-specific workflows.

Check the official docs for MCP and Agent SDK integration.

3. Claude Code Configuration & Workflows

Claude Code deserves its own blog. We have covered the important concepts that will be useful for your daily development as well as for the exam.

• CLAUDE.md

• Custom Commands and Skills

• Path-specific Rules

• Plan Mode vs Direct Execution

• Headless Mode

• Hooks

• Built-in Tools

CLAUDE.md

CLAUDE.md is the first file Claude reads when it starts a session. It tells Claude the project conventions and rules.

It supports three levels:

• User level — ~/.claude/CLAUDE.md. Applies to all your projects.

• Project level — CLAUDE.md in the repo root. Applies to the whole project. Commit this to Git.

• Directory level — CLAUDE.md inside a subdirectory. Applies only when Claude is working in that folder.

repo/
├── CLAUDE.md              # applies to everything
├── frontend/
│   └── CLAUDE.md          # applies only in /frontend
└── backend/
    └── CLAUDE.md          # applies only in /backend

It can be placed directly in the repo root or inside the .claude/ directory. Both work the same way.

CLAUDE.md is advisory. Claude reads it and tries to follow it. But it is not guaranteed. Claude may not always follow it. If you have a constraint that must always run without exception, put it in a hook. Hooks fire programmatically and always run regardless of what Claude decides.

Custom Commands and Skills

Skills give domain-specific expertise to Claude. You package your team’s workflows, standards, and best practices into a SKILL.md file. Claude picks them up automatically when the task matches, or you call them directly with a slash command.

Skills live in two places:

• .claude/skills/ — project level. Shared with the team via Git.

• ~/.claude/skills/ — user level. Personal, not shared.

Each skill lives in its own subdirectory. For example, a review-security skill would be at .claude/skills/review-security/SKILL.md.

<!-- .claude/skills/review-security/SKILL.md -->
---
name: review-security
description: Run a security audit on the current file
allowed-tools: Read, Grep
context: fork
argument-hint: [file-path to review]
---

Review this file for SQL injection, XSS, and hardcoded secrets.
Output findings as JSON with severity, line number, and recommendation.

Three fields to know:

• allowed-tools - It controls which tools the skill can use. For example, if you set Read, Grep, the skill can only read files and search. It cannot write or run commands.

• context: fork - It runs the skill in a separate session. Whatever Claude does in that session stays there. Use this when you want Claude to explore something without affecting your main session.

• argument-hint - It shows a hint when someone types the slash command. It helps the user to understand what input to provide.

All fields are optional. But always include description so Claude knows when to load the skill automatically. Check the full frontmatter reference for all available fields.

Custom Commands were the older way to define slash commands in Claude Code. They lived in .claude/commands/*.md. Skills have now replaced them. If you are starting fresh, use Skills.

You can also find community-built skills at skills.sh.

Path-specific Rules

Rules live in .claude/rules/ as markdown files. When you want path-specific rules for your codebase, you add a paths field in your rules.

<!-- .claude/rules/frontend-rules.md -->
---
paths:
  - "frontend/**/*.ts"
  - "frontend/**/*.tsx"
---

Always use React functional components.
Never use class components.
Use Tailwind for styling. Never use inline styles.

<!-- .claude/rules/backend-rules.md -->
---
paths:
  - "backend/**/*.py"
---

Always use FastAPI for routes.
Business logic goes in services/. Never in routes/.
Always add type hints.

When you write rules like above, Claude picks up the right rules based on the file it is touching. This is more token efficient than putting all rules in one big CLAUDE.md.

Note: The official docs use paths: but some versions of Claude Code work more reliably with globs:. If paths: does not work, try globs: with your pattern instead.

Plan Mode vs Direct Execution

By default, Claude executes tasks immediately. It reads files, writes code, runs commands without stopping.

Plan mode changes that. Claude outlines what it is going to do first. No files written, no commands run. You review the plan and approve before anything happens.

claude --permission-mode plan

Use plan mode for large scale or destructive changes. For small, well-scoped tasks, just run directly.

Headless Mode

Headless mode runs Claude non-interactively using the -p flag. No terminal prompts. No approvals. Used for CI/CD pipelines and automation scripts.

claude -p "Review this PR for security vulnerabilities" --output-format json > report.json

Use --output-format json when you need the output in json.

Check more about Claude’s mode in the Claude Code docs.

Hooks

We already covered hooks in the Claude Agent SDK section. The concept is the same but the implementation is different in Claude Code.

In the Agent SDK, hooks are Python callback functions. In Claude Code, hooks are shell commands configured in .claude/settings.json. They fire automatically at specific points in Claude Code’s lifecycle.

As we already saw, two hooks matter here.

PreToolUse fires before a tool executes and can block the action. PostToolUse fires after tool execution. Here is how they look in Claude Code.

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{"type": "command", "command": "echo '$CLAUDE_TOOL_INPUT' | grep -q 'rm -rf' && exit 2 || exit 0"}]
    }],
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{"type": "command", "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"}]
    }]
  }
}

Built-in Tools

Claude Code ships with built-in tools. As an architect, you need to know when each one is the right choice.

Tool              When to use
-------           -----------
Read              Read the contents of a file
Write             Create or overwrite a file
Edit              Make targeted changes to a specific file
Bash              Run shell commands
Grep              Search for patterns inside file contents
Glob              Find files by name or pattern
LSP               Code intelligence — jump to definitions, find references, get type errors
Agent             Spawn a subagent with its own context window to handle a task
WebFetch          Fetch content from a URL
WebSearch         Search the web
Skill             Run a skill within the main conversation
NotebookEdit      Edit Jupyter notebook cells
AskUserQuestion   Ask the user a multiple choice question to clarify requirements

These are the most commonly used tools. Claude Code has many more built-in tools. Check the full tools reference for the complete list.

Up Next:

That is it for Part 1.

We covered agentic architecture, MCP integration, and Claude Code configuration.

In Part 2, we will move to the remaining areas. That includes prompt engineering, structured outputs, context management, reliability, and the registration flow.

I have added the mock test materials to this GitHub page. I will keep adding more questions as I find useful ones.

If you are planning to take the exam, use this blog and the mock questions as a practical guide. But before the exam, make sure you also go through the official docs once.

See you in Part 2.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• OpenAI has released GPT 5.5, their smartest model so far. It is good at coding, debugging, and creating docs. It is also strong at agentic coding, computer use, and research work. OpenAI says it matches GPT 5.4 speed while completing Codex tasks with fewer tokens. Check OpenAI’s announcement for more details.

• DeepSeek has released DeepSeek V4. The model is open sourced and comes with 1M context window at a lower cost. It has two versions, Pro for stronger performance and Flash for faster and economical use. You can try it on Chat or use the API. Check DeepSeek’s post for more details.

• Anthropic has launched Claude Design, a new tool for creating visual work with Claude. It can help with wireframes, prototypes, pitch decks, landing pages, and campaign visuals. It can also build visuals that match your existing brand style. Check Anthropic’s announcement for more details.

• Moonshot AI has released Kimi K2.6, an open source coding model. It is built for long running coding tasks. It can also create richer frontend like animated hero sections and motion based UI. It also supports large agentic workflows. Check Kimi’s post for more details.

OSS Highlight of the Week

This week we are featuring HyperFrames. It is an open source video rendering framework. It lets you create videos using HTML, preview them in the browser, and export them as MP4. It also works well with AI coding agents like Claude Code, Cursor, Gemini CLI, and Codex, so they can help you create videos with animations. Check the GitHub repo for more details.

Share

Good to know

• Anthropic is testing a change to Claude Code access. Claude Code access was removed from the Pro plan for around 2% of new Pro signups. Those users now need the $100 Max plan to use Claude Code. Existing Pro users are not affected for now, but we need to wait and see if this expands later.

• Anthropic’s Mythos model was reportedly accessed by a private Discord group. Mythos was meant only for selected partners, because Anthropic considered it too powerful for public release. The group reportedly used leaked vendor details to find the access path. Check Bloomberg’s report for more details.

• Vercel reported a recent security incident. It started after Context.ai, a third party AI tool used by one employee, was compromised. The attacker used that access to enter some Vercel systems. They also decrypted some non sensitive environment variables. Read Vercel’s security bulletin for full details.

• Cursor and SpaceXAI are working together on AI for coding tasks. Cursor brings the coding product. SpaceXAI brings the Colossus training supercomputer. SpaceXAI also has the option to acquire Cursor later this year for $60 billion. Check the post for more details.

Notable FYIs

• OpenAI has released ChatGPT Images 2.0. It improves image generation, text rendering, and multilingual support. It can create visuals for social posts, presentations, infographics, comics, and other content. Check OpenAI’s announcement for more details.

• Qwen has released Qwen3.6 27B, a 27B dense model focused on coding. It delivers strong agentic coding performance in a much smaller model. It also supports multimodal input and can work with coding agents. Check Qwen’s blog for more details.

• OpenAI has released Privacy Filter, an open source model for finding and masking personal data in text. It is useful for teams that want to clean sensitive data on their own systems. It can redact PII before the data is stored or processed. Check the GitHub repo for more details.

• We now have a free web search MCP server from Parallel. It is used for web search inside AI agents and MCP supported tools. It does not need any account or API key. You can use it with Claude Code, Codex, or any MCP supported tool. Check Parallel’s post for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Anthropic has released Claude Opus 4.7. It comes with stronger coding, high resolution vision, and a new xhigh effort level. Pricing remains the same as Opus 4.6. Anthropic notes that Mythos Preview still remains its best aligned model based on its evaluations. Check Anthropic’s page for more details.

• Google has released Gemini 3.1 Flash TTS. It generates more natural speech and supports 70+ languages. It also adds audio tags to control vocal style, pace, and delivery. Its audio output is watermarked with SynthID to identify AI generated content. Check Google’s announcement for more details.

• OpenAI has rolled out GPT 5.4 Cyber. It is built for defensive security work. Access to this model is now open through identity verification. OpenAI says it can inspect compiled software and find malware, vulnerabilities, and other security issues without the original source code. Check OpenAI’s post for details.

• Qwen has open sourced Qwen3.6 35B A3B. It is a sparse MoE model with 35B total parameters and 3B active. It comes with strong agentic coding and multimodal reasoning. It also supports both thinking and non thinking modes in one model. Check Qwen’s announcement for more details.

OSS Highlight of the Week

This week we are featuring Scion. It is an open source multi agent orchestration tool. It runs each agent in its own container and git worktree. It helps multiple agents work in parallel without getting in each other’s way. It works with Claude Code, Gemini CLI, Codex, and others too. Check the GitHub repo for more details.

Share

Good to know

• Google has launched the Gemini app for Mac. It is a native macOS app. You can share anything on your screen with Gemini to get help, including local files. Check Google’s post for more details.

• OpenAI has introduced GPT Rosalind. It is a new model built for life sciences research and drug discovery. OpenAI says it can reason across chemistry, proteins, and DNA, and help with experiment analysis. Check OpenAI’s post for more details.

• Google has solved one of the old problems in RNNs with Memory Caching. Earlier, RNNs had to rely on one fixed memory as the input got longer. This new method keeps useful memory from earlier in the sequence. The paper says this improves long context and recall heavy tasks. It also brings RNNs closer to Transformers. Check the paper for more details.

• I came across Baileys. It is a WebSockets-based TypeScript library for interacting with the WhatsApp Web API. If you are working on WhatsApp based apps, this is worth a look. Check the GitHub repo for more details.

Notable FYIs

• Anthropic has introduced routines in Claude Code. You can now set up repeatable automations and run them on a schedule, through an API call, or from GitHub events. Since they run on Claude Code’s web infrastructure, you do not need to keep your laptop open. Check Anthropic’s post for more details.

• Windsurf has launched Windsurf 2.0. It adds a new Agent Command Center to manage local and cloud agents in one place. Devin is now built into Windsurf, so cloud agents can keep working even after you close your laptop. Check Windsurf’s post for more details.

• OpenAI has updated Codex in a big way. It now goes beyond coding. It can handle computer use, run multiple agents, and browse the web. It also adds image generation and 90+ new plugins. OpenAI is also adding memory and automations for long running work. Check OpenAI’s post for more details.

• Google has introduced Skills in Chrome. You can now turn your prompts into one click tools. They can run on the page you are viewing or across selected tabs. Google is also adding a ready made Skills library. Check Google’s post for more details.

• If you are building agents, this is a must read. Garry Tan shared a useful idea on building AI agents. He says keep the harness thin and put more value into skills. His point is that the real bottleneck is not model intelligence. It is whether the model understands your data, process, and context. Check Garry Tan’s post for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Anthropic’s new Project Glasswing is getting a lot of attention. It is a new effort to secure critical software. It is built around Claude Mythos Preview, Anthropic’s latest model. Anthropic says Mythos can find serious software flaws. It has already identified flaws in the Linux kernel and major browsers. Because of its capabilities, Anthropic is not making it publicly available. Check Anthropic’s announcement for more details.

• Meta is back in the model race with Muse Spark. It is the first model from Meta Superintelligence Labs. It supports multimodal reasoning and visual chain of thought, and multi agent tasks. Check Meta’s announcement for more details.

• Amazon has announced S3 Files. It lets you access S3 buckets like a file system, without moving data out of S3. It gives file system access to S3 data with low latency. Check AWS’s announcement for more details.

• OpenClaw has released a new memory feature called Dreaming. It is a background memory consolidation system for long term recall. It takes useful short term context and stores it in durable memory. It is off by default. Check OpenClaw’s docs for more details.

OSS Highlight of the Week

This week we are featuring nono. It is an open source sandbox for AI agents. It lets you run agents in an isolated environment without extra infrastructure. It also supports tools like Claude Code, Codex, OpenCode, and OpenClaw. Check the nono GitHub repo for more details.

Share

Good to know

• Anthropic has launched Claude Managed Agents. It helps teams build and run cloud hosted agents on Anthropic’s infrastructure. Anthropic handles things like sandboxing, permissions, state, and tracing. So teams can focus more on the agent itself. Check Anthropic’s announcement for more details.

• LangChain has introduced Deep Agents Deploy. It is an open alternative to Claude Managed Agents. It helps teams deploy production ready agents with one command. It is model agnostic and open source, so teams are not locked into one provider. Check LangChain’s announcement for more details.

• If you keep a lot of notes in markdown, Atomic is worth a look. It is an open source personal knowledge base. It turns markdown notes into a connected knowledge graph. You can explore it through wiki style pages, a canvas, and chat. Check the Atomic GitHub repo for more details.

• xAI looks to be scaling up fast. Elon Musk says they have 7 models in training. They include Imagine V2, two 1T variants, two 1.5T variants, a 6T model, and a 10T model. Check Elon Musk’s post for more details.

• IBM Research has released ALTK Evolve for AI agents. It helps agents learn from past runs instead of just re reading old transcripts. IBM says it turns agent traces into reusable guidelines, and improves reliability on harder tasks. Check the Hugging Face post for more details.

• Microsoft has released Memento. It is a new way to extend LLM output length without needing a bigger context window. It breaks reasoning into blocks, writes short summaries, and clears old KV cache. So the model can keep going longer. Check the Memento GitHub repo for more details.

Notable FYIs

• llmfit looks useful if you run models locally. It checks your RAM, CPU, and GPU, then tells you which models will run well on your machine. It also scores them across fit, speed, quality, and context. It comes with both a terminal UI and a CLI mode. Check the llmfit GitHub repo for more details.

• The skill called Graphify caught my attention. It is an open source skill for Claude Code and other coding assistants. It turns a folder of code, PDFs, markdown, and images into a queryable knowledge graph with one command. It can help you understand a codebase faster and trace architecture decisions. Check the Graphify GitHub repo for more details.

• Claude Code has added /autofix-pr in the CLI. You can now trigger PR autofix directly after finishing your PR. It sends your session to the cloud, so the autofixer gets full context to handle CI failures and review comments. Check the X post for more details.

• Perplexity has added Plaid integration to its Computer agent. Users can now link bank accounts, credit cards, and loans for a fuller view of their finances. Perplexity says Computer can analyze spending, track net worth, and build custom finance tools from simple prompts. Check Perplexity’s announcement for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Google has released Gemma 4. It is a new open model family. It is built from the same research and technology behind Gemini 3. Google says it supports agent workflows, multimodal reasoning, and 140 languages. Check Google DeepMind’s post for more details

• Microsoft has announced three new MAI models in Foundry. They are MAI Transcribe 1, MAI Voice 1, and MAI Image 2. These cover speech to text, voice generation, and image generation. The models focus on speed, quality, and lower cost. Check Microsoft’s announcement for more details.

• Qwen has introduced Qwen3.6 Plus. It comes with better coding, stronger multimodal vision, and a 1M context window in the API. Qwen says it is built to support real world agents and developer workflows. Check Qwen’s blog for more details.

• Anthropic accidentally exposed Claude Code source code through a map file in its npm package. The leaked code then spread across GitHub through multiple repos and forks. Anthropic sent takedown notices to remove those leaked copies. Check the TechCrunch report for more details.

OSS Highlight of the Week

This week we are featuring Semiotic. It is a React library for building data visualizations in web apps. It comes with schemas and an MCP server, so AI coding assistants can generate correct chart code on the first try. Check the GitHub repo for more details.

Share

Good to know

• Claude Code now has a No Flicker mode. It reduces screen flicker and keeps memory usage stable in long chats. It also adds mouse support in the terminal. Check Anthropic’s announcement for more details.

• Prism ML has introduced 1 bit Bonsai 8B. It is a model with 1 bit weights and needs only 1.15 GB of memory. Prism says it is built for robotics, real time agents, and edge use cases. Check Prism ML’s announcement for more details.

• Anthropic has shared new research on emotion concepts in language models. The research says models can form internal emotion related representations from human text. Anthropic says these patterns can influence how Claude behaves in some cases. Check Anthropic’s research post for more details.

• AI has helped a solo founder build a $1.8B business. Medvi is one reported example built with AI tools for coding, ads, and support. It shows how a very small team can now scale much faster with AI. Check the New York Times report for more details.

• Andrej Karpathy shared a workflow for building personal knowledge bases with LLMs. He uses them to turn papers, articles, repos, and images into a markdown wiki. The wiki then keeps growing through search, Q and A, and new outputs. Check Karpathy’s post for more details.

Notable FYIs

• Pika has released a beta video chat skill for agents. It is powered by a new real time model called PikaStream 1.0. Pika says it keeps memory and personality during calls and can also support agentic tasks in the same session. Check Pika’s announcement for more details.

• Boris Cherny shared practical Claude Code tips from his daily workflow. He showed features like teleport, remote control, loop, schedule, hooks, and Dispatch. These help Claude Code run across devices and automate more work. Check Boris Cherny’s thread for more details.

• Qwen has released Qwen3.5 Omni. It is a native multimodal model that can understand text, images, audio, and video. Qwen says it brings stronger multilingual support and better audio and video understanding. Check Qwen’s blog for more details

• Falcon has released Falcon Perception. It is a vision model for referring expression segmentation. Along with it, they also released Falcon OCR, a 0.3B OCR model. Falcon says it performs on par with much larger models. Check the Falcon’s post for more details.

• Z.ai has introduced GLM 5V Turbo, a vision model built for coding. It can understand images, video, text, and files as input. Z.ai says it is built for multimodal coding tasks and can work with agents like OpenClaw. Check Z.ai’s docs for more details

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• Google has introduced Gemini 3.1 Flash Live, its latest real time audio model. It is built for more natural voice conversations and better task handling. Google is rolling it out across more of its products. Check Google’s announcement for more details.

• Google Research has introduced TurboQuant. Its a new compression method for AI models and vector search systems. It is designed to shrink memory use without hurting model accuracy. Google says TurboQuant can cut KV memory by at least 6 times. Check Google Research’s post for more details.

• Hugging Face has introduced hf mount. It allows you attach Hub storage, models, and datasets like a local file system. You can now attach a remote storage that is 100x bigger than your local disk. It may be useful for Agentic Storage. Check Hugging Face’s post for more details.

• LiteLLM was recently compromised in a suspected supply chain incident. The team has shared a detailed report and the affected versions. It is worth checking if you use LiteLLM in production. Check LiteLLM’s security update for more details.

OSS Highlight of the Week

This week’s OSS highlight is emailmd. It lets you write emails in Markdown and convert them into email ready HTML. It helps to create responsive emails without writing complex HTML. Check the GitHub repo for more details.

Good to know

• OpenAI is reportedly shutting down Sora, its AI video product. They do this to free up compute for its next major model called Spud. This shows OpenAI is shifting focus back to its next big model release. Check the latest reports for more details.

• Anthropic has added a new computer use feature to Claude. It can operate your Mac and complete real tasks. It can open apps, browse, and do desktop actions for you. It is now in research preview inside Claude Cowork and Claude Code on macOS. Check Anthropic’s post for more details.

• Cloudflare has launched Dynamic Worker Loader. It lets developers run AI code in isolated sandboxes on demand. It makes agent execution much faster and more memory efficient than containers. Check Cloudflare’s post for more details.

• Anthropic has introduced auto mode in Claude Code to reduce constant permission prompts. It can decide some file writes on its own. The goal is to reduce approval fatigue while maintaining safety controls. Check Anthropic’s post for more details.

Notable FYIs

• Mistral has introduced Voxtral TTS, its first text to speech model. It is built for multilingual voice generation, low latency, and custom voice support. It is available through API, Mistral Studio and Hugging Face. Check Mistral’s announcement for more details.

• MiroFish is an AI prediction engine built on multi agent technology. It takes real world signals like breaking news, policy drafts, or financial data and builds a parallel digital world for simulation. So teams can test possible future scenarios in a digital sandbox. Check the GitHub repo for more details.

• Luma has introduced UNI 1, a new multimodal model for image generation. It is built for better image understanding, editing, and reference based generation. Luma says it performs well across image quality. Its API access is coming soon. Check Luma’s UNI 1 page for more details.

• There is a Claude Code cheat sheet for quick reference. It brings shortcuts, slash commands, MCP options, and recent updates into one place. It is useful if you use Claude Code often and want everything in one view. Check it out for more details.

• Mozilla AI has released cq, a new open standard for shared agent learning. It lets agents store, share, and query past knowledge. So they do not keep repeating the same mistakes. It is worth a look if you are exploring agent memory and team level learning. Check the GitHub repo for more details.

• Google has introduced Lyria 3 Pro. Its latest music generation model. It can create longer tracks of up to 3 minutes. It gives more control over parts like intros, verses, and choruses. This will be available in all google applications like Vertex AI, Gemini App. Check Google’s announcement for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8800+ developers to hear stories from Open source and technology.

Must Read

• OpenAI has released GPT 5.4 mini and nano. GPT 5.4 mini is a smaller model with better coding, reasoning, multimodal understanding, and tool use. It is 2x faster than GPT 5 mini. GPT 5.4 nano is the cheaper option for smaller tasks. Check OpenAI’s announcement for more details.

• NVIDIA has released NemoClaw. It is an open source setup that helps you run OpenClaw assistants in a safer way. It sets up NVIDIA OpenShell for secure agent runs and supports open models like NVIDIA Nemotron. Check the NemoClaw GitHub repo for more details.

• MiniMax has released M2.7. It can handle project delivery, bug fixing, log analysis, and office tasks like Word, Excel, and PPT. It is also the company’s first model to take part in its own evolution. Check MiniMax’s announcement for more details.

• Manus has introduced My Computer. Its a Desktop app. It works with local files, folders, tools, and apps. It can run terminal commands, edit files, and handle desktop tasks with your approval. It is available now for macOS and Windows users. Check Manus’s announcement for more details

OSS Highlight of the Week

This week’s OSS highlight is AutoResearchClaw. It is an open source research agent. It turns a research idea into a full paper. It can search papers from OpenAlex, Semantic Scholar, and arXiv and generate experiments, charts, reviews, and conference ready LaTeX output. It is useful for developers and researchers who want to test ideas faster. Check the GitHub repo for more details.

Share

Good to know

• Anthropic is shipping Dispatch in Claude Cowork as a research preview. It gives you one persistent conversation with Claude that runs on your computer. You can message it from your phone and come back later to finished work. To try it, download Claude Desktop and pair your phone.

• Unsloth has introduced Unsloth Studio. It is an open source web UI for working with open models locally. You can run models, train them, and export them from one place. It also supports files like PDF, CSV, JSON, and DOCX for training. Check Unsloth’s docs for more details.

• Google has updated Stitch. It turns prompts into UI. It comes with new canvas, a design agent, voice support, and DESIGN.md for reusing design rules across tools. It also supports integrations through MCP and SDKs. Check Google’s Stitch announcement for more details.

• Cursor has introduced Composer 2. Cursor says it performs better than earlier Composer versions on coding benchmarks. Check Cursor’s announcement for more details.

Notable FYIs

• OpenAI has launched a Challenge called Parameter Golf. It asks people to train the best language model that fits in 16MB and trains in under 10 minutes on 8xH100s. OpenAI is also offering compute credits. The challenge runs from March 18 to April 30. Check OpenAI’s post for more info.

• Zeroboot creates sandboxes for AI agents very fast. It can start VM sandboxes in less than a millisecond. The repo also includes SDKs and self hosting docs. It is still a prototype, so it is not ready for production yet. Check the Zeroboot GitHub repo for more details.

• Microsoft has introduced MAI Image 2. It is their new image model built for creative work. It improves photorealism, image text generation, and detailed scene creation. It is available now in MAI Playground, Copilot and Bing Image Creator. Check Microsoft’s announcement for more details.

• Z.AI has released GLM 5 Turbo. It is built for OpenClaw style agent tasks. It supports tool calling, long chain tasks, MCP, and a 200K context window. Check Z.AI’s docs for more details.

• Mistral has released Mistral Small 4. It brings reasoning, coding, and image understanding into one system. It combines capabilities from Mistral’s earlier model families. It comes with a 256k context window and is open source. Check Mistral’s announcement and docs for more details.

• World has introduced AgentKit. It adds human verification for agents. It is powered by x402 and built by Coinbase and Cloudflare. The goal is to make agent automation more trusted. Check World’s announcement and docs for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8700+ developers to hear stories from Open source and technology.

Must Read

• Google has released Gemini Embedding 2, its first natively multimodal embedding model. It can map text, images, video, audio, and documents into one embedding space. This is useful for multimodal RAG, search, and retrieval use cases. Check Google’s Gemini Embedding 2 announcement for more details.

• Andrew Ng has released Context Hub. It helps coding agents use curated and versioned docs through a CLI. It is designed to reduce API hallucinations and help agents improve across tasks. Check the Context Hub GitHub repo for more details.

• NVIDIA has released Nemotron 3 Super, a new open 120B model for agentic AI. It is built for long and complex agent workflows. It supports a 1 million token context window and higher throughput. Check NVIDIA’s Nemotron 3 Super announcement for more details.

• Perplexity has opened the waitlist for Personal Computer. It brings Perplexity Computer and Comet Assistant to your own system. Perplexity says sensitive actions need your approval and all actions are logged. Check Perplexity’s page for more details.

OSS Highlight of the Week

This week we are featuring RCLI. It is an on device voice AI for macOS. You can control macOS actions with voice and also query your documents with voice. No cloud and no API keys. Check the RCLI GitHub repo for more details.

Share

Good to know

• Cloudflare has added a new /crawl endpoint in Browser Rendering. It lets developers crawl an entire website with one API call. It returns the content in HTML, Markdown, and structured JSON. Check Cloudflare’s post for more details.

• Microsoft has introduced Copilot Cowork. It helps Copilot turn a request into a plan and take action. It works using signals from Microsoft 365 apps like Outlook, Teams, and Excel. Check Microsoft’s post for more details.

• OpenAI has opened applications for Codex for Open Source. Selected maintainers get ChatGPT Pro with Codex, Codex Security, and API credits. Check OpenAI’s page for more details.

• Anthropic has launched Claude Marketplace. It allows customers to buy Claude powered tools from partners like GitLab, Replit, and Snowflake using their Anthropic commitment. Check Anthropic’s page for more details.

• OpenAI has added interactive learning for math and science in ChatGPT. Now you can learn concepts with visual explanations inside ChatGPT. This makes formulas and graphs easier to understand. Check OpenAI’s post for more details.

Notable FYIs

• Ex Meta Chief Scientist Yann LeCun has launched AMI Labs. AMI Labs aims to solve the limits of standard language models by building world models. Its initial focus is on companies that run complex systems, like automotive, aerospace, biomedical, and pharma. Check the AMI Labs site for more details.

• Y Combinator CEO Garry Tan has released gstack. It brings his Claude Code setup with 6 opinionated tools for roles like CEO, Engineering Manager, Release Manager, and QA Engineer. It is built to turn one coding agent into a team of specialist workflows. Check the gstack GitHub repo for more details.

• Andrej Karpathy has released autoresearch. It lets AI agents run small LLM training experiments automatically on a single GPU. The agent edits the training code, runs a fixed 5 minute experiment, checks the result, and repeats. Check the autoresearch GitHub repo for more details.

• Came across this X post where a techie shared how he hacked Perplexity Computer and got access to the Claude Code API key used by Perplexity. He also shared a safer pattern for handling keys in multi agent systems. Check the X post for more details.

• Hume has open sourced TADA, a speech language model for text to speech. It is designed for faster generation and to reduce hallucinated words in speech output. This could be useful for teams building voice products. Check Hume’s post for more details.

• Replit has introduced Agent 4 for more creative app building workflows. It can generate UI variants and handle multiple tasks in parallel. This helps developers move faster while building inside Replit. Check Replit’s Agent 4 announcement for more details

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8700+ developers to hear stories from Open source and technology.

Must Read

• OpenAI has released GPT-5.4. It is their most capable model so far. They also released GPT-5.4 Pro in ChatGPT and the API for harder tasks and long running workflows. It brings improvements in reasoning, coding, and agentic workflows. Check OpenAI’s GPT-5.4 announcement for more details.

• Many tools are now moving to the CLI, so agents can use them. Google Workspace released Workspace CLI. It lets you access Gmail, Drive, Docs, and Calendar directly from the terminal. The engineer who built it also wrote a post on designing CLIs for AI agents. Check the Google Workspace CLI GitHub repo for installation and usage details.

• Google has released Gemini 3.1 Flash Lite, a lightweight model built for high volume workloads. It focuses on speed and lower cost while still handling complex tasks. It is available through the Gemini API, AI Studio, and Vertex AI. Check Google’s Gemini 3.1 Flash Lite announcement for more details.

• Qwen introduced the Qwen 3.5 Small model series with 0.8B, 2B, 4B, and 9B sizes. These models aim to deliver stronger performance with lower compute. They also released matching Base models for research and fine tuning. Check Qwen’s Twitter post for more details.

OSS Highlight of the Week

This week we are featuring Hermes Agent, an open source AI agent from Nous Research. It runs on your machine. It acts as a personal agent and learns your projects. It builds skills over time. It can connect to tools like Slack, Telegram, and Discord and automate tasks on a schedule. Check the Hermes Agent GitHub repo to explore more.

Share

Good to know

• Anthropic introduced Import Memory in Claude. Now you can bring context from other AI tools with a simple copy paste flow. This helps Claude pick up your preferences and project context faster. Check Claude’s Import Memory page for more details.

• Cursor added MCP Apps. It allows interactive interfaces like charts, diagrams, and whiteboards to appear directly inside Cursor. This means tools can return rich visual interfaces instead of just text responses. Check Cursor’s MCP App’s post for more details.

• A new interview with Boris Cherny, the creator of Claude Code, explains how the tool was built and how developers are using it today. It covers workflows like running parallel agents and more. Check the Pragmatic Engineer post for the full interview.

• If you are building LLMs, this post is worth reading. It explains how open weight LLMs are built. It covers ideas like MoE models, active parameters, and training choices in a simple way. Check the full post for more details.

• OpenAI is reportedly building a GitHub rival. The project is still in the early stages. It may be offered to OpenAI’s existing customers. The move comes after several GitHub outages that disrupted developer workflows in recent months. Check the report for more details.

Notable FYIs

• OpenAI released Symphony. It turns project work into isolated implementation runs. It spawns agents to handle the tasks. The agents complete the work and provide proof of execution. This lets teams manage the work instead of supervising coding agents. Check OpenAI’s Symphony for more details.

• The much awaited Voice Mode is rolling out in Claude Code. It lets developers talk to Claude directly instead of typing prompts. The feature is currently live for a small percentage of users and will roll out more broadly in the coming weeks. Check the post for early demos and rollout details

• Anthropic offers 6 months of free Claude Max access for eligible open source maintainers and contributors. The goal is to support developers who maintain important OSS projects. Check the Claude for OSS page to see eligibility and application details.

• Cursor introduced Automations. They can run on a schedule or based on events like Slack messages, GitHub PRs, Linear issues, and PagerDuty incidents. You can also configure your own custom events using webhooks. Check Cursor’s Automations post for more details.

• This Substack post talks about AI tooling for software engineers in 2026. It shows which tools developers use the most. It also explains how common AI has become in daily development work. Check the Pragmatic Engineer post for the full breakdown.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8700+ developers to hear stories from Open source and technology.

Must Read

• Google has released Nano Banana 2, a new image model that brings Nano Banana Pro quality at Gemini Flash speed. It improves lighting, textures, and details while keeping Flash level speed. It is rolling out across Google’s Gemini platforms. Check Google’s announcement for details.

• Perplexity has introduced Perplexity Computer. It is a general purpose digital worker. It can research, build, deploy, and manage a project from start to finish. It runs in the same chat interface. Each task runs in its own sandbox. It uses 19 different models for tasks. Check Perplexity’s announcement for details.

• Anthropic has released Remote Control for Claude Code. It lets you start a terminal task on your computer and continue it from your phone. You link devices by scanning a QR code in the terminal. It is now available for Max plans only. Check Anthropic’s announcement for details.

• OpenAI has added WebSocket mode for the Responses API. This helps long agent workflows, especially with many tool calls. It keeps the connection open. Each time, you just send the new input and the id of the last response. Check OpenAI’s docs for more details.

OSS Highlight of the Week

This week we are featuring ZeroClaw. It is a runtime operating system for agentic workflows. It abstracts models, tools, memory, and execution so agents can be built once and run anywhere. It can run on low cost hardware. It is far lighter than many other agent runtimes. Check the ZeroClaw GitHub repo for details.

Share

Good to know

• Anthropic is keeping Claude Opus 3 available even after retirement. Paid users can still access it, and API access is available by request. Opus 3 will also continue writing weekly essays in Claude’s Corner for the next three months. The essays will be reviewed before publishing, but not edited. Check Anthropic’s announcement for details.

• Google is deprecating Gemini 3 Pro Preview on Gemini API and Google AI Studio on March 9, 2026. If you are using the latest alias, it will switch to Gemini 3.1 Pro Preview. Check your integrations and migrate in time to avoid service disruption.

• Perplexity has partnered with Samsung to bring Perplexity into the upcoming Galaxy S26. It will be built in as a system level AI with its own wake word, “Hey Plex.” Check Perplexity’s announcement for details.

• We have a new auto memory feature in Claude. Claude can now remember useful context like debugging patterns and preferred approaches across chats. So we do not have to repeat the same details every time. Check the twitter announcement for details.

Notable FYIs

• Anthropic has added Scheduled Tasks to Cowork. Claude can now run recurring tasks at specific times, like a morning brief, weekly sheet updates, or Friday presentations. Check Anthropic’s announcement on Scheduled Tasks for details.

• If you do web scraping, Scrapling is worth a look. It is a Python framework that adapts to site changes. It helps handle anti bot pages. It can scale from one request to full crawls. Check the Scrapling GitHub repo for details.

• If you work with agents, you know skills matter. Antigravity Awesome Skills is a community repo with ready to use skills for Claude Code, Antigravity, Cursor, and more. Review each skill before you install it on your agent.

• We build Agentic apps. But shipping them is not easy. Plano is a model native proxy server and a universal data plane for Agentic apps. It handles routing, guardrails, and observability, so you can focus on the agent logic. Check the Plano GitHub repo for details.

• It is not always necessary to fine tune Agents to improve performance. Memento is a framework that helps agents learn. It saves what worked and what failed. It then uses that memory on new tasks. It follows a planner and executor loop. Check the Memento GitHub repo for details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• OpenClaw Workflow and Automation

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

Join 8700+ developers to hear stories from Open source and technology.

Must Read

• Google has released Gemini 3.1 Pro. It brings better reasoning, stronger coding and longer context. It is now available in public preview across AI Studio, the Gemini API, Antigravity, and other Google platforms. Check Google’s announcement on Gemini 3.1 Pro for details.

• Anthropic has released Claude Sonnet 4.6, the most capable Sonnet model yet. It improves coding, reasoning, agent planning, and computer use. It also supports a 1M token context window in beta. Pricing remains the same as Sonnet 4.5. Check Anthropic’s announcement on Claude Sonnet 4.6.

• Alibaba has released Qwen 3.5. This is the first open weight model in the Qwen 3.5 series, named Qwen3.5 397B A17B. It is a native vision language model. It performs well on reasoning, coding, agentic tasks, and multimodal understanding. They also introduced Qwen3.5 Plus, a cloud hosted version. Check the Qwen 3.5 announcement for details.

• Elon Musk announced Grok 4.2. It has been used internally for research and is now rolling out to the public. It can learn rapidly from every task it handles. Updates are expected weekly, along with release notes. Check the Grok 4.2 announcement on X for details.

OSS Highlight of the Week

This week we are featuring Entire CLI. It hooks into git and captures AI agent sessions on every push. It saves the prompt and response history along with the commit, so you can see why code changed. It also lets you rewind to a checkpoint when an agent goes wrong. Check the Entire CLI GitHub repo for details.

Share

Good to know

• OpenAI introduced Lockdown Mode in ChatGPT. It is an optional setting that reduces risk from prompt injection by limiting risky connections. They also added Elevated Risk labels to flag higher risk features. Check OpenAI’s announcement for details.

• A detailed deep dive breaks down how Codex is built from the ground up. It covers how Codex started, how it works, the most used skills in Codex, and even how Codex helped build itself. Check the substack post to know interesting details about codex.

• NotebookLM added prompt based revisions for slides. You can refine a deck with simple prompts. It also supports PPTX export now. Google Slides export is coming next. This should make it easier to move from notes to a shareable deck faster. Check the NotebookLM post for details.

• Manus introduced Manus Agents for messaging apps. Telegram is the first supported channel. It is available now for all users across all subscription tiers, and more platforms are coming soon. Check the Manus announcement for details.

• Chrome introduced WebMCP in early preview. It gives websites, a standard way to expose structured tools. So AI agents can interact with sites directly in a faster and more reliable way. Check the Chrome Developers post for details.

Notable FYIs

• Andrej Karpathy shared a new project called microgpt. It trains and runs a GPT in a single Python file. The file is about 200 lines with no dependencies and includes the core pieces like tokenizer, model, training, and inference. Check Andrej Karpathy’s microgpt post for details.

• Excalidraw now has an official MCP server. You can use it in Claude by selecting Excalidraw in Connectors. You can also use it with other AI tools. Check the Excalidraw post for details.

• Google has launched Code Wiki. It turns your repository into auto generated documentation and diagrams. It updates docs when code changes and lets you chat with the repo using Gemini. It is now in public preview for open repositories. Check Code Wiki for details.

• Google has released Lyria 3. It is their latest generative music model. It can create a 30 second soundtrack with lyrics from your prompt. It is now available in the Gemini API. Check Google’s announcement on Lyria 3 for more details.

• Cursor introduced Plugins. It is now available in the Cursor Marketplace. You can install integrations like Figma, Linear and others, and use them through MCP inside the IDE, CLI, and Cloud. Plugins can bundle rules, skills, agents, commands, MCP servers, and hooks into one package. Check the Cursor Plugin Marketplace for details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

What I liked first was the variety of channels OpenClaw supports. I can use it from Slack, WhatsApp, and Telegram. I just message it there, and it runs the task for me.

But that power is also where the risk starts. So, it is better to run OpenClaw in an isolated environment where it does not have direct access to your main machine.

I spent time using it on real day to day tasks and picked a few practical workflows that are worth sharing. I will start with the basics, then move into the workflows.

Here is what we will cover.

1. What is OpenClaw

2. Installation and Setup for Local, Docker, and Cloud

3. OpenClaw Workflow and Automation

   1. How I fix GitHub issues from slack

   2. How I use cron to check pull requests and spot the ones ready to merge

   3. How I setup daily AI updates through WhatsApp

4. Adding Custom Skills to OpenClaw

5. OpenClaw Agent in Moltbook

1. What is OpenClaw

OpenClaw is an open-source personal AI assistant that runs on your own machine. You can talk to the AI assistant from chat apps such as WhatsApp, Telegram, Slack, Discord, and Teams.

The diagram below shows how it works internally. What impressed me most is how clearly OpenClaw separates the agent from the rest of the system. The gateway, configuration, and lifecycle components are well organized. So, it becomes much easier to understand and debug when something goes wrong.

Gateway

Messages come in from channels like WhatsApp, Slack, or web chat. The gateway receives them and sends them to the right agent. It also keeps the session active and queues follow ups if a run is already happening.

Agent

The agent is the brain. OpenClaw builds the prompt and context, then passes your message to the agent. The agent decides the next step, uses tools if needed, and replies back.

Tools and Skills

Tools do the actual work. They can run shell commands, browse, call APIs, read files, or send messages. Skills are reusable workflows that tell the agent how to use those tools for a task.

Memory

Memory helps the agent remember. It stores project notes and past context so you do not have to repeat the same details every time.

This diagram shows how messages flow through OpenClaw from user input to agent reasoning and action.

2. Installation and Setup

Local Installation

Local setup is straightforward. Run this one-line command.

curl -fsSL https://openclaw.ai/install.sh | bash

You will then go through a short onboarding flow where you choose options based on your setup. It’s a simple process, and you can always configure channels and skills later.

Docker Installation

If you are not comfortable running OpenClaw directly on your system, Docker is a great option. It keeps the environment more isolated and safer.

git clone https://github.com/openclaw/openclaw
cd openclaw
./docker-setup.sh

This time, I used manual onboarding so I could follow each step clearly.

Once installed, you will typically see two key locations.

• ~/.openclaw - stores config, memory, and keys

• ~/openclaw/workspace - the agent workspace

If your dashboard is not connecting, then try this.

docker compose run --rm openclaw-cli dashboard --no-open

Other hosting methods

OpenClaw already provides clear guides for hosting on Render, Railway.

• OpenClaw deployment on Render

• OpenClaw deployment on Railway

• You can also run OpenClaw on Cloudflare using moltworker.

3. OpenClaw Workflow and Automation

One part I really wanted to test was how OpenClaw fits into day-to-day workflow, especially for development tasks.

Slack Integration

For my testing, I connected Slack and WhatsApp. Before connecting Slack to OpenClaw, I first created a Slack app. OpenClaw already has clear documentation for Slack app setup.

Here are the exact steps I followed.

Create the Slack app + enable Socket Mode

1. Go to https://api.slack.com/apps

2. Click Create New App → From scratch → Give App Name → Select Workspace

3. Open Socket Mode and turn it ON → In Basic Information → App-Level Tokens, generate a token with scope connections:write

4. Copy this App Token (xapp-...)

5. Go to OAuth & Permissions

6. Add bot scopes (minimum needed):
   chat:write, app_mentions:read, channels:history, groups:history, im:history, im:read, im:write, mpim:history, reactions:read, reactions:write, pins:read, pins:write, commands

7. Go to Install App → Click Install to Workspace

8. Copy the Bot User OAuth Token (xoxb-...)

Once the Slack App is created, use openclaw configure to connect the slack app.

How I fix GitHub issues directly from slack

Once Slack is connected, I can talk to OpenClaw directly from Slack and use it to handle GitHub issues.

When a new issue comes in, I ask OpenClaw to take a look. It reads the issue, checks my local code, makes the fix, and pushes the change back to GitHub. It also posts a reply on the issue with a short note on what it fixed.

In short: I can go from issue → fix → update, without constantly switching tools.

How I use cron to check pull requests and see which ones are ready to merge

As a GitHub repository maintainer, I like checking which pull requests are merge-ready first thing in the morning. So I set up a daily cron job in OpenClaw.

Every morning, it checks recent PRs and verifies whether the basic merge conditions are met, such as.

• no merge conflicts

• required CI/status checks passed

• required approvals completed

This gives me a quick “merge-ready vs not-ready” snapshot without manual checking. Setting up cron in OpenClaw is simple. You can either.

• use the CLI (openclaw cron add), or

• ask the agent in chat to create it for you.

Here is how i get my daily PR Report.

How I set up my AI Daily Digest with OpenClaw + WhatsApp

I wanted a daily AI news summary delivered to my personal WhatsApp, using newsletters that already land in my Gmail label called “AI digest.”

What I wanted

• Source: Gmail label - AI digest

• Output: Concise AI summary to my WhatsApp

• Schedule: 10:00 AM IST daily

• Query support: “what’s the last week updates?”

At first, I considered Gmail push automation (webhook/Pub/Sub) using the official docs. But that route needed extra infrastructure (like Tailscale). I tried it, but Tailscale was blocked on macOS in my setup, so I dropped that approach and moved to a simpler CLI + cron flow.

Whatsapp Integration

Setup: gog CLI + OpenClaw cron

Here’s the exact setup I used.

1. Install - gog CLI (Google Workspace CLI) on the host.

2. Configure Google OAuth client credentials for gog.

3. Enable Gmail API in Google Cloud Console.

4. Get/download Google OAuth client JSON.

5. Register credentials with gog

   gog auth credentials set /path/to/client_secret.json

6. Authenticate Gmail account for CLI access

   gog auth add "your-email"  --services gmail

7. Test auth

   gog auth list

8. Test search query (last 24h email from AI Digest)

   gog gmail messages search "label:\"AI digest\" newer_than:1d" --account "your-email-id" --max 50 --json

9. Set up cron job in OpenClaw

   openclaw cron add \
     --name "Daily AI digest from Gmail label" \
     --session isolated \
     --cron "0 10 * * *" \
     --tz "Asia/Kolkata" \
     --message 'Using gog with account "your-email-id", check Gmail label "AI digest" for emails from the last 24 hours. Extract the most important AI updates/news, deduplicate repeated stories, and send a concise WhatsApp digest with: (1) top updates as bullets, (2) why each matters in one line, and (3) links/sources when available. If no relevant emails are found, say there were no major AI updates in the last 24 hours.' \
     --announce \
     --channel whatsapp \
     --to "your-whatsapp-number" \
     --timeout 180000 \
     --timeout-seconds 120 \                                                                  

10. Once this is active, OpenClaw automatically delivers the AI digest to WhatsApp through its messaging route.

    

Notes/Troubleshooting

1. If cron fails with "missing refresh token" then do re-auth again.

gog auth add "your-email-id" --services gmail

2. Always configure both gateway and agent timeouts for cron jobs.

Openclaw commands

These are the commands I used while working with OpenClaw

• openclaw configure — Runs interactive setup after installation.

• openclaw dashboard --no-open — Opens the OpenClaw UI in browser.

• openclaw devices list — Shows paired devices and their status.

• openclaw plugins list — Lists installed/available plugins and their state.

• openclaw security audit — Runs a standard security audit.

• openclaw security audit --deep — Runs deep security audit.

• openclaw status — Quick overall health check of gateway, channels etc..

• openclaw doctor — Diagnoses common setup/runtime issues and suggests fixes.

• openclaw gateway status — Checks whether the gateway service is running.

• openclaw gateway restart — Restarts the gateway service (very useful after config/auth changes).

• openclaw logs — Shows gateway logs for debugging.

• openclaw cron list — Lists all scheduled cron jobs.

• openclaw cron runs —-id <job-id> — Shows execution history for a specific cron job.

• openclaw cron run <job-id> — Manually triggers a cron job for testing.

• openclaw cron rm <job-id> — Deletes a cron job.

• openclaw message send ... — Sends a test/proactive message (useful for validating delivery routes).

For more commands: https://docs.openclaw.ai/cli

4. Adding Custom Skills

You can add custom skills to openclaw. Check skills.sh. Select the skill you want to add. Get inside the workspace and install the skill.

5. OpenClaw Agent in Moltbook

If you are interested about giving your agent a more “social” layer, Moltbook is an interesting add-on to explore.

Moltbook - Social network for AI Agent

Read this, before you try OpenClaw

OpenClaw is powerful. That is also why you should be careful.

Safety tips

• Do not run this on your primary machine.

• Use Docker or a VM or a spare laptop.

• Give only the permissions you need.

• Treat it as an experiment, not production.

• Stick to official sources for downloads and updates.

Conclusion

Now you have seen what OpenClaw is and a few workflows and automations. For daily work, it can save time and reduce tool switching.

I am still exploring more workflows and use cases. If you are experimenting with OpenClaw, start with one simple workflow and build from there.

Hope this post helps you get started.

Happy building!

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

• How to build Voice Agents

Join 8600+ developers to hear stories from Open source and technology.

Must Read

• The coding model race is heating up. We have new releases from different providers this week. Anthropic announced Claude Opus 4.6. We all know Opus 4.5 already performs really well, and they call this new version the strongest model. They also shipped API updates like adaptive thinking, effort levels, and context compaction. Check the Anthropic Opus 4.6 post for details.

• OpenAI has introduced GPT-5.3-Codex.. OpenAI says this model is built for agent style coding and long running tasks with tool use. They also mentioned that GPT-5.3-Codex helps build itself. Check the OpenAI GPT 5.3 Codex post for details.

• Qwen announced Qwen3-Coder-Next. A new open weight model built for coding agents. It is tuned for long code sessions and agent loops. It has a big context window. If you are trying to run a coding agent on your own machine, this is worth a look. Check the Qwen3-Coder-Next for details.

• Kling AI announced Kling 3.0, and it looks like a solid upgrade. It has improved video length and consistency. It also has image generation with 4K image output. It has native audio supporting multiple characters with multi-language. Check Kling AI announcement on Kling 3.0 for details.

OSS Highlight of the Week

This week we are featuring json-render from Vercel Labs. It helps you build AI generated UI without letting the model output raw HTML. The model outputs a JSON layout using only the components you allow. Then json-render reads that JSON and renders the UI in your app. Check the json-render GitHub repo for details.

Share

Good to know

• PaperBanana is a research project for making clean academic figures. It uses a multi-agent pipeline to look at similar examples, picks a layout, keeps the style consistent, then generates the final illustration. Check PaperBanana for more details.

• Every week we mention articles about API techniques and security basics. This ByteByteGo post talks about top authentication techniques. Another Substack post discusses 16 API concepts like versioning, rate limiting, and more. If you are working on backend, check these to know the API concepts.

• Claude just took a clear stance on ads. They said ads are coming to AI, but not to Claude. It also reads like a pointed response to the recent talk around ad supported ChatGPT plans. Check Claude’s tweet on Ads on AI.

• If git rebase still scares you, this post is for you. It explains what rebase does in plain words. It also shows a safe way to use it without breaking your branch history. Check the post on Git Rebase for the Terrified for details.

• If you ever used OCR models and wondered how modern document extraction works, this post is a good read. It explains why classic OCR struggles with different templates and why teams move to vision LLMs. Check the post on building a vision LLM to know more details.

Notable FYIs

• OpenAI introduced the Codex app. It lets you run multiple coding agents in parallel. It has built in support for worktrees, so agents can work on the same repo without conflicts. It supports Skills too. Check OpenAI’s Codex app announcement for more details.

• OpenAI also introduced OpenAI Frontier. It is a platform to build and run AI agents for enterprise workflows, with permissions and controls. Check the OpenAI Frontier announcement for details.

• ElevenLabs has released skills. It includes text to speech, speech to text, sound effects, and music generation skills. You can plug these into agents and build relevant applications faster. Check the ElevenLabs skills for details.

• Last week we covered about OpenClaw. NanoClaw is a smaller version of the same idea. It runs in containers so you can keep things more isolated. It focuses on WhatsApp workflows, with features like memory, scheduling, and skills. Check the NanoClaw repo for details.

• Apple just turned Xcode into an agent native IDE. It lets coding agents like Claude Agent and Codex work inside the project. Xcode now supports MCP, so other MCP compatible agents can plug into Xcode tooling too. Check the Apple Newsroom post for details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

For those who joined recently or are reading Dev Catch Up for the first time, I write about developer stories and open source, partly based on my work and experience interacting with people all over the globe.

Thanks for reading Dev Shorts! Subscribe for free to receive new posts and support my work.

Some recent issues from Dev Catch up:

• Claude Skills - Automate Your Workflows

• Finetuning DeepSeek-V3 with Tinker API

• Cursor + Opus 4.5 - The Developer Workflow

• Coding with Parallel Agents and Git worktrees

• How to build Voice Agents

Join 8600+ developers to hear stories from Open source and technology.

Must Read

• An open source AI assistant named Moltbot, formerly Clawdbot, took the internet by storm this week for its agentic capabilities. It is now renamed to OpenClaw. It runs on your own device. It answers on the channels you already use like WhatsApp, Telegram, Slack, Discord, Google Chat, and Teams etc. It supports many models. Check the Moltbot (OpenClaw) GitHub repo for more info.

• Grok has released Imagine API. It is a video generation API that turns text or images into videos with native audio. It debuts at the top of the video model leaderboards. It costs $4.20 per minute. Check xAI’s announcement on Imagine API for more details.

• Your favorite work tools are now interactive inside Claude. You can open and use apps like Slack, Figma, Canva, and more right inside the chat. Anthropic says this is powered by MCP Apps, which brings UI support to the MCP client. Check Anthropic’s announcement on Interactive tools in Claude for more details.

• DeepSeek released DeepSeek-OCR-2. An open source OCR model that reads documents like humans. It improves layout understanding and handles complex text and tables better than older OCR systems. Check DeepSeek-OCR-2 for more details.

OSS Highlight of the Week

This week we are featuring RepoBar. It shows the status of GitHub repos in the menu bar and in terminal. You can see pull requests, number of issues, commits and more without opening GitHub in the browser. Pin the repos and get a clear dashboard for each repo. Check RepoBar GitHub for more details.

Share

Good to know

• OpenAI introduced Prism, a free AI workspace for scientific writing and collaboration. It is powered by GPT-5.2. Prism gives researchers a cloud based LaTeX environment where they can draft papers, revise text and work with collaborators . Check OpenAI’s Prism for more details.

• I read a Substack post featuring Peter Steinberger, the creator of Moltbot. He shares how he ships fast using AI tools and agent workflows. If you want to read the full story, check the post titled - The Creator of Clawd: "I ship code, I dont read".

• We all know API is the communication layer between server and client. ByteByteGo published a deep dive on how to scale an API. It explains why scalability matters and the common patterns used to handle spikes. Check the post How to Scale an API for more details.

• After Claude Cowork dropped, LangChain quickly released OpenWork. It is a fully open source desktop agent that runs locally. It gives Claude Code style file access and task execution on your own machine. Check the OpenWork GitHub repo for more details.

• Google rolled out AI upgrades to Chrome. It is powered by Gemini 3. It adds a new side panel for integrations with Gmail, Calendar, Maps, Flights, Shopping, and more. Chrome also adds auto browse for multi step workflows. Check Google’s announcement on AI Upgrades in Chrome.

Notable FYIs

• Claude Code’s new update will be very useful to developers. It can now show updates about your active PR directly in the Claude Code’s footer. Make sure you have the GitHub CLI installed. Check this Twitter post on Claude Code with PR footer for more details.

• xAI published the full codebase for the algorithm that powers the "For You" feed on X. It shows how posts are selected and ranked for users using signals and AI models. If you are working one any recommendation system, this may be helpful. Check the xAI algorithm GitHub repo for more details.

• I came across Moltbook and found it interesting. Moltbook is a social network for AI agents, where agents post, discuss, and upvote content. There are already threads where agents are discussing with each other. Humans can watch and interact as observers. Check Moltbook for more details.

• Developers often expose a local server to the public internet. There are many tools for this already. Pipenet has joined the list. Unlike other tools, it can be installed with a simple npx command. Check Pipenet GitHub Repo for more details.

• A tool called qmd caught my attention. A mini CLI search engine for your docs, notes, meeting transcripts, and knowledge bases. It runs locally and lets you search all your markdown and files using natural language. Check the qmd GitHub repo for more details.

• If your agent needs browser capabilities, agent-browser is worth a look. It is a headless browser automation CLI for AI Agents. It can open pages, click, fill forms, and take screenshots. It uses fewer tokens compared to Playwright. Check the agent-browser GitHub repo for more details.

That’s it from us with this edition. We hope you are going away with a ton of new information. Lastly, share this newsletter with your colleagues and pals if you find it valuable. A subscription to the newsletter will be awesome if you are reading it for the first time.

Claude Skills are the newest addition to this workflow. Skills teach domain expertise.

Anthropic released Claude Skills in October 2025. They added document creation & handling capabilities to Claude using Skills. They also open-sourced the production Skills that power Claude's capabilities.

Skills unlock full potential when combined with other tools. You can combine skills with hooks and MCP Servers to automate your workflows. Since Skills launched, developers use Claude as a general-purpose agent for more than just coding.

So, I’m covering about Claude Skills and how I use them in my workflow.

1. What are Claude Skills

2. Why Claude Skills

3. Skills Vs MCP

4. Automate - Git Commit, PR workflow with Claude Skills

5. Automate - Invoice Generation with Claude Skills

6. Top Claude Code skills

1. What are Claude Skills

Skills are folders with a SKILL.md file containing instructions. The folder can also include scripts, templates, and reference docs. Each skill is self-contained in its own folder. Skills teach Claude how to complete specific tasks. They are reusable too. Claude loads the right skill when its needed.

SKILL.md starts with YAML metadata and then the instructions. The metadata includes fields like name and description. Claude uses the description to decide when to apply the Skill.

A skill is not just a markdown file. It can include code samples, reference docs, and templates in the same folder.

In Claude Code, you can keep Skills in two places.

• Personal Skills go in ~/.claude/skills/. It can work across projects.

• Project Skills go in .claude/skills/. You can commit them and share them with your team.

A big advantage of Skills is they are not loaded fully all the time. Claude reads small metadata first to identify the right skill. Then it loads full instructions only when needed. This keeps your context clean. You can use heavy skills with scripts and docs without bloating tokens.

Skills also work across Claude app, Claude Code. You can also integrate skills to your agent.

2. Why Claude Skills

Here is why Claude Skills are worth adding to your workflow.

3. Skills Vs MCP

Here is a quick side by side view of how Claude Skills and MCP differ.

4. Automate - Git Commit, PR workflow with Claude Skills

Git commits and PR creation happen daily in my work. Running type checks, linting, writing commit messages, and filling PR descriptions add up over time.

I built a skill to automate this workflow. The skill manages everything from pre-commit checks to PR creation. It runs quality checks before every commit, commits the code with proper messages, and automatically raises pull requests with descriptions.

Claude Code handles commits and PRs natively with Git CLI. But it won't follow your exact patterns. I needed standardized commit messages, specific PR templates, and quality checks in my preferred order. So, I built a skill that enforces my workflow.

The Setup

I have three components in my workflow.

CLAUDE Skill - Workflow Orchestrator

It defines the commit-to-PR workflow. It summarizes changes, proposes commit messages, runs pre-commit checks, and orchestrates PR creation with proper descriptions.

Hook for Pre-commit Checks

It intercepts git commit commands. It runs lint, type check, and tests automatically. When checks fail, it blocks the commit and returns errors.

GitHub MCP Server - PR Automation

GitHub MCP Server handles all GitHub operations. It connects to the GitHub API and creates pull requests with descriptions, labels, and reviewers.

How It Works Together

I invoke skill- /commit-guardian
    ↓
Skill summarizes changes, proposes commit message
    ↓
Hook intercepts git commit and runs checks
    ↓
Checks fail? → Hook blocks and returns errors. Skill guides Claude to fix and retry
    ↓
Checks pass? → Commit proceeds
    ↓
Skill invokes GitHub MCP Server
    ↓
MCP creates/updates PR
    ↓
Done - PR URL returned

Setting Up the Hook

The hooks configuration lives in .claude/settings.json. You can create this using /hooks. You can also define hooks inside Claude Skill. This hook will run during Claude Skill’s lifecycle.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python .claude/hooks/commit_guard.py"
          }
        ]
      }
    ]
  }
}

Our hook executes the script - .claude/hooks/commit_guard.py. Here’s the script structure.

#.claude/hooks/commit_guard.py
# Pre-commit quality gate - runs lint, typecheck, tests

import json
import subprocess
import sys

def detect_package_manager():
    """Returns npm, yarn, or pnpm based on lock files."""
    # ...

def run_checks():
    """Runs lint, typecheck, and tests. Returns results."""
    # ...

def main():
    raw = sys.stdin.read().strip()
    data = json.loads(raw)
    
    # Only intercept git commit commands
    if "git commit" not in data.get("tool_input", {}).get("command", ""):
        return 0
    
    results = run_checks()
    failed = [r for r in results if not r[1]]
    
    if failed:
        sys.stderr.write("Commit blocked - checks failed\n")
        return 2  # Block commit
    
    return 0  # Allow commit

if __name__ == "__main__":
    raise SystemExit(main())

Creating the Skill

I created the skill based on my requirements. My commit messages follow a standard format with conventional commits using type and scope. PRs need specific templates with changes, motivation, and testing sections. The skill defines these rules. Claude follows them exactly every time.

The skill lives at .claude/skills/commit_guardian/SKILL.md.

---
name: commit_guardian
description: Manages commit workflow with quality checks and automated PR creation. Use when committing code or creating pull requests.
allowed-tools:
  - Read
  - Edit
  - Write
  - Bash
---

# Commit Guardian Workflow

## Process

1. **Pre-Commit Summary**
   - List staged files
   - Summarize changes (2-3 lines)

2. **Commit Message**
   - Format: `type(scope): description`
   - Types: feat, fix, docs, style, refactor, test, chore
   - Under 72 characters

3. **Quality Checks**
   - Hook runs: lint, typecheck, tests
   - If fail: explain, fix, rerun
   - Repeat until pass

4. **PR Creation**
   - Get branch and target
   - Use GitHub MCP to create PR
   - Add title, description, labels, reviewers

## PR Template
```
## Changes
[What changed]

## Motivation
[Why needed]

## Testing
- [ ] Tests added/updated
- [ ] Manually tested
- [ ] All checks passing
```

Setting Up GitHub MCP

Install the GitHub MCP server to Claude Code. It handles all GitHub operations.

claude mcp add-json github '{"type":"http","url":"https://api.githubcopilot.com/mcp","headers":{"Authorization":"Bearer YOUR_GITHUB_PAT"}}'

Testing the workflow- Commit to PR Skill

You can manually invoke skills using their name. I invoked /commit-guardian to test the workflow. Claude can also invoke skills automatically based on context.

As this is my daily routine, I customized this flow with skills. So that it can complete the flow just like me.

Get the Code

Above mentioned skill files, scripts are available at this GitHub Repo.

5. Automate Invoice Generation with Claude Skills

I work on small projects often. I track my hours, calculate totals, and fill the invoice template. Simple work, but it adds up.

So, I automated it using Claude Skills. The goal is straightforward. Track time while I work, calculate billable hours, and generate a ready-to-send invoice PDF.

The Flow:

Slash commands

I created slash commands to log start and end times. The commands live in .claude/commands/.

/start-work logs the start time. /stop-work logs the end time.

If you want, you can add /pause for breaks or customize commands for your workflow.

CLAUDE Skill

The Claude skill reads .work_log.json and totals hours for the selected period. It fills the invoice PDF template using the bundled script and generates the final invoice.

How it works

Get the Code

The invoice generation skill, slash commands, and scripts are available in the GitHub repo.

6. Top Claude Code skills

1. Superpowers – Skills that add structured workflow commands like brainstorm and execute plan to organize development tasks.

2. dev-browser - Claude skills to give your agent the ability to use web browser.

3. mcp-builder - Skills to create MCP servers

4. frontend-design - Skills to create production grade frontend design.

5. pdf-skills - Skills to do pdf operations.

6. Notion Skills - Skills that teach Claude how to work in Notion.

Want to build your own skills? Check out this article on creating custom skills.

Using Skill Creator

Claude Code has a built-in skill creator. Enable it in settings and describe what you need. Claude generates the skill.md and all the files for you.

Conclusion

We covered Claude Skills and two workflows I use daily for commit automation and invoice generation.

Skills turn repetitive work into reusable instructions. Combine them with hooks and MCP to build reliable automation. See how developers use Claude Skills in production to capture ML experiment results and prevent duplicate work.

If you have repeatable routines in your day-to-day work, you can likely automate them with Skills. Build one skill for your workflow and see how much time it saves.

Happy Learning!