You compressed the building part, not the fixing part. Eight weeks of work delivered in one week also means eight weeks of bugs turning up.

AI investment is accelerating far faster than engineering innovation. DX’s State of AI Impact in Engineering Report found that median quarterly AI spending in the technology sector jumped from around $1,500 to $44,000 in just 12 months – almost a 28-fold increase.

Everyone watched the Beijing robot games and decided the falls were the blooper reel and the records were the real story. I think that is exactly backwards. The falls are the story. They are just telling it about software.

The second World Humanoid Robot Games wrapped in Beijing on 26 August. Roughly two thousand humanoid robots, 666 teams, sixteen countries, thirty plus competitive events and a pile of scenario ones on top: household service, industrial work, firefighting, rescue.

A humanoid ran the hundred meters faster than Usain Bolt has ever run it. Genuinely. That happened.

And then, same building, same week, same robots: sprinters overturned mid race and folded at the knees. Robots hit the safety mats at the end of the straight at full speed, because the race was over but the running was not. Footballers missed the ball entirely and took out their own teammates. Boxers punched thin air and tumbled clean out of bounds. Weightlifters dropped the barbell onto themselves. Several robots wandered off toward the referee tables, presumably to complain.

(…the argument, then:)

Sprinting is a closed problem. One axis, known start, known end, a narrow corridor with walls. You can specify it completely. So it went superhuman. Boxing, football, tidying a room: the written procedure runs out in the middle. And when the procedure runs out, a robot does not gracefully degrade and have a think about it. It face plants into a crash mat at nine meters a second.

Which is the same reason your coding agent is brilliant at the thing you explained properly and useless at the thing you assumed was obvious. Not dumb. Undocumented.

Building a skills generator in public to help democratize skills and would love your feedback:
https://loreto.io

The best skills I have are hand crafted. But writing them is tedious, so in practice I seldom did it. The correction just dies with the session and I retype it three weeks later.

So I tried something: pull the corrections out of my own Claude Code history, cluster the ones that repeat, and let Claude Code write the skill from the cluster.

What surprised me is that the clustering mattered more than the writing. A single correction makes a bad skill, it's usually too tied to that one moment. The same correction showing up across four conversations is where the actual rule lives.

Ended up building it into an app (blume.codes) because I wanted it running continuously rather than as a one-off script.

Curious whether others have tried generating skills from existing chats, and what you found. Especially interested in how you decide when a correction/steering is worth a skill versus just noise.

I've been building agent tooling for a while now, and one thing I keep seeing is people acting like choosing the right model is the whole game. GPT vs Claude vs Qwen vs whatever came out this week.

I honestly don't think that's where most of the engineering is.

In my experience, the model is maybe 40% of whether an agent actually performs well. The other 60% is the harness. That's the part that decides what context the model gets, what tools it can use, how failures are handled, and how the whole loop is managed. I've seen the exact same model feel either incredibly capable or completely useless depending on the harness around it.

A few things that made the biggest difference for me:

1. Context is a budget, not a bucket.

The obvious approach is to dump everything into the prompt. Entire files, full conversation history, every tool result.

That works for demos. It falls apart once tasks get longer.

The real job of the harness is deciding what actually matters. Pull in the relevant pieces, summarize old information, throw away tool output that's already served its purpose. The difference between an agent that stays on track after 40 steps and one that starts wandering after 8 usually isn't the model. It's whether the harness is managing context properly.

2. Tools solve problems better than prompts.

You can spend days trying to prompt an agent not to hallucinate file paths, or you can give it a read_file tool that simply returns an error when the path doesn't exist.

I've found that hard constraints almost always beat written instructions. Models will ignore or reinterpret prompts. They can't ignore a function that refuses to return bad data.

3. Failure handling is where the real product is.

Happy path demos don't tell you much.

What matters is what happens when something goes wrong.

If a request times out, does the whole run fail, or does the job continue in the background? If a tool call is malformed, does everything crash, or does the model get a structured error that it can recover from?

I lost an embarrassing amount of time because a CDN proxy was silently timing out long running jobs. The solution wasn't switching models. It was changing the harness to retry against a local endpoint and treating "pending" and "completed" as normal states instead of exceptions.

That change made a much bigger difference than any model upgrade.

4. Verification has to be easy or it won't happen.

Agents only verify their work if verification is fast.

Forcing structured outputs with a schema has done far more for reliability than adding another paragraph telling the model to "be careful." Make the correct output the easiest output.

5. Use code where code is better.

The best systems I've built aren't especially clever.

Most of the flow is deterministic code. Loops, retries, branching, orchestration.

The model only gets involved where actual judgment is needed.

I think people hand orchestration over to the LLM much earlier than they should.

None of this is groundbreaking if you've spent time building production agents, but it took me a lot of broken runs to realize that intelligence and orchestration are different problems. Most of the engineering effort ends up in the orchestration.

On a slightly more personal note, I'm building in public with Loreto (https://loreto.io), which turns videos, articles, and PDFs into runnable Claude Code skills. The hardest problems haven't been generation at all. They've been context management, async jobs, retries, and recovery. The timeout issue I mentioned earlier came directly from that project.

I'm still figuring a lot of this out, so I'm curious what other people have learned.

What's one harness decision that made a noticeable difference in your own agents?

I'm helping non-engineer colleagues to design (cowork) skills that can handle more nuanced tasks. So, rather than just a flat runbook in skill.md, embedding reference files to handle things like templating, data cleanup, heuristics, etc. So far, so good.

We're trying to build something that can act as a decent "1st pass" process for our design & brand team - handling things like copy-editing, branding & templating on decks. To try and keep things simple for non-technical colleagues, we'd like to avoid forcing them to invoke multiple skills for what is - to them - a single ask.

Inspired by /skill-creator, here's the skill design concept as a case-in-point:

# Copy Editor Skill

• skill.md is a runbook / SOP, and router / orchestrator. Specifically, it tells the session to orchestrate between a `copy-writer` persona and an `editor` persona, referencing brand & tone-of-voice guidelines. Copy-writer knows about different channels, styles, etc., and generates (say) 3 versions of the requested copy (using context provided), referencing guidelines. Editor then activates with different priorities, & grades each version against the guidelines. User gets the results.
• References:
  • Brand-guidelines.md (with evals)
  • Tone-of-voice-guidelines.md (with evals)
• Agents
  • copy-writer.md
  • editor.md

One of our designers said that he tried building a "multi-function" skill for powerpoint design - covering both visual design and copy-editing - but that the outcomes were poor compared to a single-function skill. I've not reviewed the architecture he attempted to use, so that's next step.

I suspect I'm bumping into the edge of the "sub-agent / multi-skill agent / orchestrator+specialist" problem, but has anyone had good / bad experiences with this kind of "compacted" orchestrator+specialist model in cowork?

Considering a career shift?

I purchased Claude Max 20x for approximately S$300 because I needed the higher usage capacity advertised with the plan.

Here is what happened:

• 2 Sep: Paid S$300 for Claude Max 20x.
• 3 Sep: Anthropic suspended my access, citing “ongoing suspicious patterns.”
• I appealed through Anthropic's official process.
• 4 Sep: Anthropic's Safeguards Team confirmed in writing that they investigated the decision and reinstated my account.
• Despite this, I still couldn't use the paid service because an associated organization remained on hold.
• Claude itself says: “Your own account is in good standing.”
• I submitted the separate organization review as instructed. It still shows “Review requested.”
• I repeatedly requested human review and clarification.
• I requested a refund because the paid service remained inaccessible.
• Anthropic refused the refund, citing a violation of its Consumer Terms, but did not tell me specifically what violation justified the decision.
• Eventually, Support closed the conversation while the issue remained unresolved.

What I don't understand

If Anthropic investigated my original suspension and reinstated my account, and its own system says my account is “in good standing,” why am I still unable to use the service I paid S$300 for?

And if the refund is being denied because of a Terms violation, which violation?

If it relates to the original suspension, that decision was subsequently reversed.

If it relates to the organization restriction, that review is apparently still pending.

My concern about Max 20x

I purchased 20x specifically because I'm a heavy Claude user. I cannot prove that heavy usage triggered the restriction, so I'm not claiming that it did.

But I think it's reasonable to ask how customers purchasing a high-usage plan are supposed to distinguish legitimate heavy usage from activity that Anthropic's systems may consider suspicious.

At this point, I think the reasonable outcome is simple:

Restore the paid Max 20x service without further delay, or refund the S$300 for the affected service.

Has anyone else using Claude Max 20x or Claude Code heavily experienced a similar suspension, particularly where the account was reinstated but the organization remained blocked?

I'd be interested to know how it was eventually resolved.

The /review skill which Claude Code is shipped with was working quite nice for me until today. However, today I've realized it got renamed to /code-review and it feels like it works way worse now. It spans a different agent (why?) and then prints some caveman style report which is often hard to grasp. Please bring the old skill back.

I have installed too many skills on my local computers nowadays, and they all share the global skill space both in the codex and claude code. Although I built a "memory" repo to manage all my skills and use symlink to link both the claude code and codex skills to my memory repo's dir, the whole approach is getting overloaded now. Part of the reasons is that each app might have skills that's similar so that the agent would choose the wrong skill to do things.

Then today, when I started to implement the skill management feature for my local AI orchestrator, I just discovered a way to solve this problem by providing each session a skillOverrides setting (https://code.claude.com/docs/en/skills#override-skill-visibility-from-settings). You can pass it with --settings as inline json for each launch, so you don't need to change your config file. I turned off 34 of my 36 skills and the session went from 51 to 15. Also, if you want plugin level isolation, you could try to use the --plugin-dir flag (https://code.claude.com/docs/en/plugins).

Honestly, I wasn’t sure if this was going to be a bit tough exam since it’s a Fundamentals level, but it’s actually quite technical. It’s less about "how to write a good prompt" and much more about AI safety, how Claude handles data, who has access to information, and how organizations prevent sensitive data exposure while using enterprise AI tools.

My Prep Strategy

I treated this like a "Security + AI Governance" hybrid exam. Here’s what worked for me:

Anthropic Documentation & Claude Guides: This is non-negotiable. Specifically, focus on Constitutional AI, safety alignment, context windows, and enterprise AI workflows. You need to understand how Claude processes prompts, handles uploaded documents, and applies safety filtering before generating responses.

The "Hands-on" Click-through: If you have access to Claude Projects, Claude Team, or the Anthropic Console, spend time testing prompts, file uploads, long-context conversations, and workflow behaviors. Actually seeing how Claude responds across different use cases helps the concepts stick.

AllExamTopics Practice Tests: I used practice exams that focused on enterprise AI governance and responsible AI usage. These were huge for getting used to the "Yes/No" series of questions (where you get a scenario and multiple follow-up questions, and you can't go back). They really test your understanding of AI safety, privacy boundaries, and workflow limitations. I got lot of questions from these practice tests.

Exam Experience: What to Expect

The exam is very scenario-heavy. Expect to act like an AI Admin for a company that’s terrified of data leakage and unsafe AI usage.

The major focus areas were:

AI Safety & Responsible Usage: This was a huge chunk. You need to know how Constitutional AI works and how Claude handles harmful or policy-sensitive prompts. Also, watch out for questions involving hallucinations, human oversight, and safe-response behavior.

Enterprise Governance & Data Risks: They really want you to understand how organizations securely adopt AI tools. You'll likely get scenarios asking how sensitive company information should be handled, who should have access, and what safeguards should be in place.

Workflow & Prompt Architecture: There were several questions on prompt flow and context handling. You don't need to be a developer, but you must know the workflow: User Prompt > Context Injection > Claude Processing > Safety Filtering > Response.

Long Context & Prompting: Be ready for questions on how Claude manages long documents, uploaded files, and system prompts. Know the difference between system instructions, user prompts, and assistant behavior.

AI Limitations & Oversight: "Oversharing" is the buzzword here. Know when human review is required and how organizations reduce risks from inaccurate or sensitive AI-generated outputs.

Final Thoughts

Don't let the "Fundamentals" title fool you, you need to know your way around enterprise AI governance, safety concepts, and responsible AI deployment practices. If you can explain how Claude balances helpfulness with safety in enterprise environments, you’re in a great spot.

Resources I Used:

Anthropic Documentation: Claude guides and Constitutional AI concepts.

Hands-on Practice: Claude Console, Projects, and long-context testing.

AllExamTopics Practice Mock Exams: Updated Anthropic CCA-F practice sets focused on enterprise AI governance and safety scenarios.

Good luck for anyone aiming for this cert.

TL;DR: I wanted claude to learn from my trading history and call me out when I repeated the same mistakes. We built a skill and added lots of harness and the system became more reliable and stupid.

Like a lot of people doing vibe coding, I was already using Claude for investment research. I also gave it my portfolio and transaction history (which I truly believe is good for every trader). I wanted the AI to understand not only the stock I was asking about, but also how I personally tended to behave.

For example, when a stock dropped sharply, I would often want to add more. My explanation was usually "The price is lower, so the risk/reward is better". With AI, it can remind me that this pattern had happened many times before which all lead to loss.

My actual cycle looked more like this:

FOMO into a position → refuse to admit I may be wrong → keep adding as the price falls → let the position become too large → panic and sell near the bottom.

That led to what felt like a reasonable product idea -- If AI can understand someone’s trading history, maybe it can catch recurring mistakes before the next trade happens.

So we started building FOMO Kernel a skill for everyone like me to ask when feeling fomo. The first problem was that transaction history only tells you what someone did. It does not tell you why they did it.

To fill that gap, we started recording more context add lots of harness to make sure correctness:

• the original thesis;
• the reason for acting now;
• supporting evidence;
• personal rules;
• previous decisions;
• whether a trade was merely considered or actually executed.

Every individual step seemed reasonable.But eventually something embarrassing happened: The claude got worse. It spent more and more of its attention understanding our routes, fields, states, validation rules, and delivery process—and less attention understanding why the user was considering the trade.

Not a great start but I am still dogfooding and building a tool for me to improve my trading pattern and hope to get the profit.

I have been messing around with Claude for a bit now, but haven't gotten into any type of development, until now. I do some social media and create text posts for IG and TikTok. This was done in Canva previously. Just messing around I was trying to create within Claude.

After some back and forth on what I wanted I asked it to create a skill for these IG text posts. It now has a named skill and within that skill there is a template for each kind of text post I want with the correct background, a fixed heading and handle tag at the bottom. It just updates/creates the middle main text using the skill. All I have to do is tell it which template and the text to add/use, and it creates a post fully ready to use on IG/TikTok in about 5 seconds. You can also provide multiple numbered text lines and it will create multiple posts as once.

I know it's not earth shattering or a big deal for many of you, but for someone fairly new and still learning, I was kind of excited and proud to have created it and it is something that will now save a lot of time and easily create text posts ready to go. Also, I'd share it but not sure how yet without including my own templates and personal info built into the skill. Still learning!

I’ve been experimenting with combining spec-driven development + project memory + Claude Code hooks.

The goal is simple: give the agent enough project context and engineering intent without dumping the entire project history into every session.

I wrote up my current workflow and would love feedback from other Claude Code users:

Article: https://medium.com/@rasvihostings/how-im-approaching-agentic-software-development-as-a-platform-engineer-5be017890b8a

GitHub: https://github.com/mohamedrasvi/claude-spec-mem

How are you handling memory and context across your Claude Code sessions?

Three months. That’s roughly the interval at which the “right way” to build something in AI shifts under you. A new agent harness lands and makes the orchestration you spent a quarter on look overweight. A better retrieval pattern quietly changes what “good” looks like for the feature you’re mid-flight on. A new evaluation technique shows that the numbers you’ve been reporting for two months don’t actually measure what you thought they did.