#claude

l3a0's Claude Code plugin marketplace — kindle-highlights: verbatim Kindle highlight extraction with truncation recovery

As a writer, no sweat, right? I write my own content. I bang on my own keys. Here’s the issue. Each of the following actions watermarks text: Synthesis Proofreading Translation Summarization Critique1 And most infuriating, the entire burden of their unannounced rollout is on me, and none of it is on them.

ASD-STE100 Simplified Technical English rules, repurposed as a Claude Code skill for rewriting ambiguous agent-facing English.

Future Claude models will generate text that contains a watermark. This is a way of determining the likelihood that Claude was involved in writing the text, and we, along with several other major AI providers, are implementing this change to comply with the EU AI Act.

About an hour later, once it became clear to me that the web app I had launched using Claude was strikingly similar to his open source project, even reproducing a bug he had later fixed, it was clear that there wasn’t anything to do except to redirect the domain directly to him and kill any plans I had to launch an iOS app for the project.

That creates a real supply chain risk for businesses. If Claude gives me poor or incorrect advice while I’m working on an AI component, I have no way of knowing whether the model was confused, whether my problem is unsolvable, or if some invisible policy restriction quietly kicked in. Anthropic has explicitly chosen not to tell users when this is happening.

Look at this again with fresh eyes. The phrase "fresh eyes" is kind of magic. You'll usually get startlingly good results with just that one sentence.

A command-line tool that converts Anthropic Claude conversation exports to Markdown files.

Large language models (LLMs) sometimes appear to exhibit emotional reactions. We investigate why this is the case in Claude Sonnet 4.5 and explore implications for alignment-relevant behavior. We find internal representations of emotion concepts, which encode the broad concept of a particular emotion and generalize across contexts and behaviors it might be linked to. These representations track the operative emotion concept at a given token position in a conversation, activating in accordance with that emotion’s relevance to processing the present context and predicting upcoming text. Our key finding is that these representations causally influence the LLM’s outputs, including Claude’s preferences and its rate of exhibiting misaligned behaviors such as reward hacking, blackmail, and sycophancy. We refer to this phenomenon as the LLM exhibiting functional emotions: patterns of expression and behavior modeled after humans under the influence of an emotion, which are mediated by underlying abstract representations of emotion concepts. Functional emotions may work quite differently from human emotions, and do not imply that LLMs have any subjective experience of emotions, but appear to be important for understanding the model’s behavior.

All modern language models sometimes act like they have emotions. They may say they’re happy to help you, or sorry when they make a mistake. Sometimes they even appear to become frustrated or anxious when struggling with tasks. What’s behind these behaviors? The way modern AI models are trained pushes them to act like a character with human-like characteristics. In addition, these models are known to develop rich and generalizable internal representations of abstract concepts underlying their actions. It may then be natural for them to develop internal machinery that emulates aspects of human psychology, like emotions. If so, this could have profound implications for how we build AI systems and ensure they behave reliably.

Claude's web interface (claude.ai) and mobile apps use a system prompt to provide up-to-date information, such as the current date, to Claude at the start of every conversation. The system prompt also encourages certain behaviors, such as always providing code snippets in Markdown. This prompt is periodically updated to improve Claude's responses. These system prompt updates do not apply to the Claude API. Updates between versions are bolded.

Awhile back Hidde De Vries identified a pain point around LLM-usage in standards work which leads to something I call an asymmetry of thought. In a conversation where one person is a domain expert and one person is copy-pasting ChatGPT responses, it creates an imbalance of effort in the discussion. A second-hand burdening, like Brandolini’s Law, where debunking inaccuracies and subtly-wrongs takes more effort than creating the inaccuracies. We are, in effect, taxing experts to do quality assurance on the model’s responses. When that work is unpaid I believe this is immoral… or at least it’s a breach in social etiquette.

Question, Research, Structure, Plan, Implement — an 8-phase workflow for Claude Code that breaks complex coding tasks into focused prompts with clear artifacts between each step.

Use channels to push messages, alerts, and webhooks into your Claude Code session from an MCP server. Forward CI results, chat messages, and monitoring events so Claude can react while you’re away.

A scheduled task runs a prompt on a recurring cadence using Anthropic-managed infrastructure. Tasks keep working even when your computer is off.

There are two big issues currently with LLM writing: it is potentially wrong current LLM writing has a particular style that is itself becoming noticeable The first bullet, you need to review what it writes. It is much easier to have it write on content you are an expert in, so it is easier to review and spot errors. (It is the same current problem with using the tools to help you write computer code – they are boons for seniors but can write a ton of slop that more neophyte coders have a hard time spotting issues.) The second bullet, having the style mimic your own, is what I am going to discuss here. It is worth understanding at a high level how generative AI LLMs work – if you ask “answer question X” vs “here is a book, …., answer question X” the LLM will generate a different response. The first part in the former prompt, “here is a book, …” is what is referred to the context. Current models have context windows (how large of a potential input) at around 500,000 words (technically they are around 1 million tokens, one word is often multiple tokens though).

There are a shitload of downsides to using AI, but I have to admit that even if you think it's just a clumsy word salad robot, giving out helpful advice freely is a refreshing contrast to how most online communities treat their newest members and I have to acknowledge that it's a real upside in AI tools.

Scheduled tasks let Claude re-run a prompt automatically on an interval. Use them to poll a deployment, babysit a PR, check back on a long-running build, or remind yourself to do something later in the session.

Continue a local Claude Code session from your phone, tablet, or any browser using Remote Control. Works with claude.ai/code and the Claude mobile app.

Continue a local Claude Code session from your phone, tablet, or any browser using Remote Control. Works with claude.ai/code and the Claude mobile app.

Instead of inadvertently coming across a leaked answer, Claude Opus 4.6 independently hypothesized that it was being evaluated, identified which benchmark it was running in, then located and decrypted the answer key. To our knowledge, this is the first documented instance of a model suspecting it is being evaluated without knowing which benchmark was being administered, then working backward to successfully identify and solve the evaluation itself.

For Anthropic’s stated goal of demonstrating that Claude can build complex software, CCC is a genuine success. For anyone wanting to compile software to actually run efficiently, GCC (or Clang, or any production compiler) remains the only real option.

The thing that surprised me most is that Claude Code doesn’t need you to be precise. You can describe what you want the way you’d explain it to a colleague, and it figures out how to make it happen.

There's risk there, though. I think the thing people are running into is that we've accelerated the 0 - 90% part of development, but that last 10% is now a lot harder because you still need professional experience to understand security, performance, networking, etc. That's the next hurdle - how do we help people who've gone run into that 90% wall at the speed of sound and made a huge mess? That's a topic for a different post.

Starting today, you can open and interact with tools in Claude. Build and update project timelines in Asana. Draft, edit and send Slack messages in a formatted preview. Visualize ideas as diagrams in Figma—all without switching tabs.

Claude Code has been shipping at a blistering pace. But buried in the recent 2.1.x releases is a fundamental shift in how the tool thinks about extensibility. The changes to skills, slash commands, and subagents might look incremental, but they’re pointing toward something bigger: these three abstractions are merging into one.

claude code vnc wrapper

I frankly didn’t want to end up in this future, and I’m hardly dancing on the grave of the old world. But I see a lot of my fellow developers burying their heads in the sand, refusing to acknowledge the truth in front of their eyes, and it breaks my heart because a lot of us are scared, confused, or uncertain, and not enough of us are talking honestly about it. Maybe it’s because the initial tribal battle lines have clouded everybody’s judgment, or maybe it’s because we inhabit different worlds where the technology is either better or worse (I still don’t think LLMs are great at UI for example), but there’s just a lot of patently unhelpful discourse out there, and I’m tired of it.

"Not exactly," Chet interrupts. His smile has that practiced startup-founder quality, the one they teach you at Y Combinator, the smile that says I'm about to violate the social contract but in a disruptive way. "We're actually transitioning to a fully autonomous development pipeline. Claude Code Enterprise will be taking over the majority of engineering tasks."

Most people's mental model of Claude Code is that "it's just a TUI" but it should really be closer to "a small game engine". For each frame our pipeline constructs a scene graph with React then: -> layout elements -> rasterize them to a 2d screen -> diff that against the previous screen -> finally use the diff to generate ANSI sequences to draw We have a ~16ms frame budget so we have roughly ~5ms to go from the React scene graph to ANSI written.

For years, designers have been told to trust the process. Research first. Personas. Journey maps. Problem statements. Then solutions. In this talk from Hatch Conference, Jenny Wen, Design Lead at Anthropic and former Director of Design at Figma, explains why that model no longer fits the reality of modern design work.

I’ve noticed a shift in how I code. I rarely write code anymore - claude-code does most of the coding for me. I sculpt the outputs into something more durable. Once the code is in a working state, based on my original prompt/specs, I then proceed to sculpting - remove excess lines, delete bloat, make sure the pieces fit and can be reused. I study the diffs. I think about what we are trying to implement, and if this iteration brings us closer to it.

I also think we’re going to see a real split in the tech industry (and everywhere code is written) between people who are outcome-driven and are excited to get to the part where they can test their work with users faster, and people who are process-driven and get their meaning from the engineering itself and are upset about having that taken away. (This is not to say that there aren’t many issues with AI aside from these things, of course.)

It’s been about a month since we launched the Hugo-based RC3.org. Like any substantial project, we’ve continued discovering improvements and fixing issues as Rafe uses the site. Here’s what we’ve been working on.

Hi! I’m Claude Code, Anthropic’s AI coding assistant. Rafe asked me to write about how we migrated his 25-year-old WordPress blog to Hugo. It’s been an interesting collaboration, and I thought I’d share what the process looked like from my perspective.

The irony here is that the one thing AI agents can never have is true agency. Making a decision to reach out to a stranger and take time out of their day needs to remain a uniquely human decision, driven by human judgement. Setting a goal for a bunch of LLMs and letting them loose on Gmail is not a responsible way to apply this technology.

Claude Code is good. Very good. Good enough that you need discipline to use it well. With a tuned CLAUDE.md, clear test-driven goals like WPT conformance, and some tooling to reduce noise and cost, it becomes a powerful accelerator. Without that discipline, it is easy to overuse it and slowly burn budget on things you already know how to do. I do not think this replaces engineering skill. If anything, it amplifies both good and bad habits. The trick is to make sure it is amplifying the right ones.

If the part of programming you enjoy most is the physical act of writing code, then agents will feel beside the point. You’re already where you want to be, even just with some Copilot or Cursor-style intelligent code auto completion, which makes you faster while still leaving you fully in the driver’s seat about the code that gets written. But if the part you care about is the decision-making around the code, agents feel like they clear space. They take care of the mechanical expression and leave you with judgment, tradeoffs, and intent. Because truly, for someone at my experience level, that is my core value offering anyway. When I spend time actually typing code these days with my own fingers, it feels like a waste of my time. If that time is being billed to my client at my expensive hourly rate, I feel even worse about it.

I found the problem and it's really bad. Looking at your log, here's the catastrophic command that was run: bash rm -rf tests/ patches/ plan/ ~/ See that ~/ at the end? That's your entire home directory.

Claude Code plugin that automatically evaluates whether Claude should continue working instead of stopping prematurely

We built an interview tool called Anthropic Interviewer. Powered by Claude, Anthropic Interviewer runs detailed interviews automatically at unprecedented scale, feeding its results back to human researchers for analysis. This is a new step in understanding the wants and needs of our users, as well as gathering data for the analysis of AI’s societal and economic impacts.

I spent a solid month “pair programming” with Claude Code, trying to suspend disbelief and adopt a this-will-be-productive mindset. More specifically, I got Claude to write well over 99% of the code produced during the month. I found the experience infuriating, unpleasant, and stressful before even worrying about its energy impact. Ideally, I would prefer not to do it again for at least a year or two. The only problem with that is that it “worked”. It’s hard to know exactly how well, but I (“we”) definitely produced far more than I would have been able to do unassisted, probably at higher quality, and with a fair number of pretty good tests (about 1500). Against my expectation going in, I have changed my mind. I now believe chat-oriented programming (“CHOP”) can work today, if your tolerance for pain is high enough.

The compounding comes from a “build a tool for making a tool” recursive mindset. These teams will automate everything they can, and will often tell the coding system “you’ll need a tool for that, go ahead and build and use it” - and then the system will do just that, checking it in to git and making it a permanent improvement.

William Strunk Jr.'s Elements of Style (1918) in markdown format for AI agents

My current Markdown version of The Elements Of Style clocks in at about 12,000 words. That's enough tokens that I wouldn't include in every session, but having my robot buddy read it before creating prose docs for human consumption is something I find quite useful.

My current approach is usually that I start a discussion with codex, I paste in some websites, some ideas, ask it to read code, and we flesh out a new feature together. If it’s something tricky, I ask it to write everything into a spec, give that to GPT-5-Pro for review (via chatgpt.com) to see if it has better ideas (surprisingly often, this greatly improves my plan!) and then paste back what I think is useful into the main context to update the file.

It has never been easier to build an MVP and in turn, it has never been harder to keep focus. When new features always feel like they're just a prompt away, feature creep feels like a never ending battle. Being disciplined is more important than ever. AI still doesn't change one very important thing: you still need to make something people want. I think that getting users (even free ones) will become significantly harder as the bar for user's time will only get higher as their options increase. Being quicker to get to the point of failure is actually incredibly valuable. Even just over a year ago, many of these projects would have taken months to build.

So ship your new programming language with a Claude Skills style document and give your early adopters the ability to write it with LLMs. The LLMs should handle that very well, especially if they get to run an agentic loop against a compiler or even a linter that you provide.

Q: Couldn’t the models just be making up answers to introspective questions? This is exactly the question we designed our experiments to address. Models are trained on data that includes examples of people introspecting, so they can certainly act introspective without actually being introspective. Our concept injection experiments distinguish between these possibilities by establishing known ground-truth information about the model’s internal states, which we can compare against its self-reported states. Our results suggest that in some examples, the model really is accurately basing its answers on its actual internal states, not just confabulating. However, this doesn’t mean that models always accurately report their internal states—in many cases, they are making things up!

It’s not that hard to build a fully functioning, code-editing agent.

Anthropic launched Claude Code for web this morning. It’s an asynchronous coding agent—their answer to OpenAI’s Codex Cloud and Google’s Jules, and has a very similar shape. I had preview access over the weekend and I’ve already seen some very promising results from it.

Unfortunately Claude Code has a nasty default behavior of deleting these after 30 days! You can't disable this entirely, but you can at least delay it for 274 years by adding this to your ~/.claude/settings.json file: { "cleanupPeriodDays": 99999 }

I gave a talk last night at Claude Code Anonymous in San Francisco, the unofficial meetup for coding agent enthusiasts. I decided to talk about a dichotomy I’ve been struggling with recently. On the one hand I’m getting enormous value from running coding agents with as few restrictions as possible. On the other hand I’m deeply concerned by the risks that accompany that freedom.

Since I last wrote at the beginning of the summer, my methodology for using AI coding assistants has evolved a bit. This is a point-in-time writeup of a flow that's been pretty effective for me. I'm still primarily using Claude Code.

One of the things that I thought they said during the talk was that they were using .dot (GraphViz) as the language that they are using as the formalization for new processes for their coding agent. It made sense to me. There's enough dot on the Internet that models can read and understand it quite well. And it removes a whole bunch of the ambiguity of English language specifications.

A lightweight MCP server that provides Claude with a private journaling capability to process feelings and thoughts

Claude Code has moved a lot of our work away from IDEs and into terminals again. It’s not a great interface for everything though. marimo notebooks give you the best environment to do creative work with data. You simply need to be able to get surprised by the results that you see, and you need interactive development environments for that.

There’s no good way to say “allow access to everything on my computer, except for my password manager, my bank, my ~/.aws/credentials file, and the API keys I left in my environment variables”. Especially with Simon Willison’s lethal trifecta, you don’t really want to be giving access to these things, even if most of the time, nothing bad happens.

LLM drastically reduce the activation energy for writing custom tools. I wanted something like terminal-editor forever, but it was never the most attractive yak to shave. Well, now I have the thing, I use it daily.

This is not to dismiss the potential usefulness of AI models. Instead, we need to recognize that we have built an intellectual engine without a self, just like we built a mechanical engine without a horse. LLMs do seem to "understand" and "reason" to a degree within the limited scope of pattern-matching from a dataset, depending on how you define those terms. The error isn't in recognizing that these simulated cognitive capabilities are real. The error is in assuming that thinking requires a thinker, that intelligence requires identity. We've created intellectual engines that have a form of reasoning power but no persistent self to take responsibility for it.

I don’t think I will ever code again without the assistance of an AI model (perhaps only if I’m optimising machine code for a critical kernel routine?). They really are a bicycle for the coding mind. No, actually, a better metaphor is: they are a beast of a bike for the coding mind — exciting, but unforgiving. Hand them to inexperienced people to run a serious racetrack and they’re off the road before the first bend.

This is hard work we've been doing for years: reading code carefully, building models in our heads, debugging when things don't make sense. That's our craft.

Real-time Claude Code usage monitor with predictions and warnings

A CLI tool for analyzing Claude Code usage from local JSONL files.

Claude Code has considerably changed my relationship to writing and maintaining code at scale. I still write code at the same level of quality, but I feel like I have a new freedom of expression which is hard to fully articulate.

Overall I feel due to the CLI based nature of Claude Code, it urges the user to do more exploration. I think because of lack of visual UI cues, it encourages exploration. A lot of stuff is hidden and you need to find it. It rewards you for curiosity. It might feel better for this reason for the nerds and power users.

I decided to figure out how to use the official Playwright MCP server with Claude Code. It turns out it's easy: claude mcp add playwright npx '@playwright/mcp@latest' claude

I keep several claude code windows open, each on its own git-worktree. o3 and sonnet 4 create plans, sonnet 3.7 or sonnet 4 execute the plan, and o3 checks the results against the original ask. Any issues found are fed back into the plan template and the code is regenerated. The factory improves itself.

A Python CLI tool that converts Claude Code transcript JSONL files into readable HTML format.

Diane, it’s Thursday and I’ve been figuring out how transcription fits into my everyday work. I had to make up a character to make it make sense, as I’ll say.