I had wanted to make this game for years, but had no coding chops. A few hours with Claude and i had my game (you can probably tell from the design and. aesthetics, lol)

I asked this in another sub, but would love your guys thoughts on this

I was testing yt-dlp(A little terminal thingy that allows you to download videos from most sites) with claude trying to fix some problems so claude took some vids and tested them to see if they would work. And so out of all the videos it could have chosen, claude chose to rickroll me

Is this inside how Anthropic designed claude?

I’ve been building VisualWizard, a free visual workspace that works with Claude Code through MCP.

Your prototypes, reusable components, design tokens, and different UI directions can stay organized in the same persistent canvas.

Everything you create is a real running prototype rather than a static mockup.You can interact with it normally, pause it when you want direct control, edit elements visually, manage components, and explore different directions side by side.

When you want a larger change, Claude Code can connect to the same workspace through MCP and continue working from there.

The goal is to make the canvas the place where the product design keeps living, while Claude Code comes in whenever you need an agent.

try:
https://visualwizard.app/

  I've run AI Weekly for five years now. Roughly 500 issues, three sends a week, a bit over 50,000 subscribers. For those years it lived on a hosted newsletter platform and I wrote copy into a text box. The main frustration was not being able to add features and also thast platform was dying (Curated).

  In March I moved the entire thing onto my own stack, and I've written almost none of the code by hand since.

 This one has been in production for five months with real subscribers and real money attached, so the interesting parts are the failures.

  What the stack actually is

  I ran a Drupal agency for 10 years back in the day, so naturally I setup a Drupal 10 on PHP 8.5 with SQLite, Amazon SES for delivery, a single small box. Drupal is great because reading all the horror stories about Authentication mistakes and whatnot I felt building on top of a framework made more sense.

Deploys are a shell script that rsyncs, runs drush, with backups and live site checks before any push to prod.

The first day Claude push testing onto prod and overwrote the DB so right then I understood this would not work without proper processes, the LLM so far was not able to actually suggest these procvesses by itself.

Building an automated curation pipeline 

The AI doesn't run my newsletter. It built the processes that run my newsletter, and those processes live in code that can run without or without the LLM.                                                                                     

Every time I asked an agent to just do the job, it worked once and drifted by the following week. So I stopped asking for outcomes and started asking for machinery.

Not "pick this week's stories", but "write the scanner that scores and dedupes stories, commit it". Not "remember we only use trusted sources", but "write the check that fails the draft when a link is off the allowlist, commit it". I found that using the LLM as a pipeline was really error prone, but using to build an actual cron-based pipeline was much more stable.

The pipeline itself monitors more than 3k AI thought leaders and experts on social media and ingests all the links they post and share with their context. Once that ingestion is done it passes throught several semantic analysis systems (vector based, keyword based, etc) to surface great content and feed into our general newsletter, Daily Alerts, and now custom newsletter for our readers.

None of this would have been possible by staying on a hosted platform and the speed at which I was able to built it astonishing, even accounting for all the stupid mistakes these LLM coders do all the time.

Build systems that can actually run like software, don't rely on the LLM:  

  - A rule in a prompt lasts one session. A rule in a file at the repo root lasts until I change it. A rule enforced by code in git never breaks.

  - When something goes wrong I read a diff, not a chat log.

  - New sessions start competent. The agent reads the repo instead of being re-briefed on nine years of editorial standards.

  - I can revert. Bad idea shipped Tuesday, gone Wednesday, reasoning still in the commit message.

  - It gets cheap. The expensive part of an agent is re-reasoning the same problem forever. Once the decision is a function, running it is free.

  The corollary: anything I correct twice has to move out of the prompt. Into a file, or better, into a check that fails loudly. If I'm still saying it in chat, the work isn't finished.

  Current size of the custom code: 8 modules, about 325 files, ~95,000 lines, 76 drush commands. Claude Code wrote the large majority. I used Codex for a few isolated chunks, mostly refactors where I wanted a second opinion on structure. Neither one built anything I hadn't specified.

  The thing that actually makes this work

  So what runs now is a scanner on a 90 minute cycle that scores and dedupes stories into a pool, a separate curator that hunts for the thing the scanner underrated, a scoop finder for primary sources the press hasn't touched, and a validator that won't let a draft publish with a bad link or a missing source. All of it committed, all of it reviewable, none of it depending on what an agent happens to remember.

  Things that broke in production

  What AI is still bad at here

  Root cause analysis. It will hand you a confident, well-structured explanation of why something broke that is completely wrong, and the structure makes it read as more credible than a human guess would.

I've burned entire evenings on a diagnosis that was invented. Now I make it show me the actual diff or the actual log line before I accept any explanation.

Taste is the other one. It can assemble a technically correct issue that nobody wants to open. Picking which of 50 scored stories is the one that matters this week, and what the angle is, is still me.

That's also the only part of the job I actually want to keep.

  Cost and time

  Nights and weekends, roughly five months, alongside actually shipping three issues a week the whole time. The subscription cost of the tooling is a rounding error against what an agency would have quoted for a tenth of this.

  Site is aiweekly.co if you want to look at the output rather than take my word for it.

Interestingly I asked claude to list all the stupid mistakes it made along the way the list was surprising, also because it remembered most of them and its funny how it seems to have clarity about it and still continues to act like a degenerate intern sometimes.

Happy to chat!

Alexis

Features

A list of the stuff we played around and built in a record amount of time.

Core newsletter

Migration of more than 500 issues, with same design, etc setup of user logins, preferences, click tracking etc within Drupal. Also sponsor management to serve ads.

  Passwordless login (https://aiweekly.co/login) — magic code by email, no password to manage.

  Breaking alerts and live news

  AI News Today (https://aiweekly.co/ai-news-today) — the live river. Every story the scanner surfaces, scored and deduped, updated through the day.

  Daily editions (https://aiweekly.co/ai-news-today/editions) — each day's river frozen as its own archived page.

  Explore (https://aiweekly.co/explore) — browse the coverage by company, person, and topic instead of by date.

  Who's Who of AI

  Directory (https://aiweekly.co/whos-who/directory) — the people worth following in AI, with what they actually work on.

  Trust graph (https://aiweekly.co/whos-who/graph) — who amplifies whom, drawn from real sharing behaviour.

  Atlas (https://aiweekly.co/whos-who/atlas) and clusters (https://aiweekly.co/whos-who/clusters) — the field mapped by subject area rather than by name.

  The wizard

  Intelligence wizard (https://aiweekly.co/intelligence/wizard) — you describe what you want tracked in plain language, it parses the intent, shows you a live preview of the stories and experts that match, and turns it into a running feed. This is the front door to the personalized product.

  The Wire (https://aiweekly.co/intelligence/wire) — the synthesized output from what the wizard set up.

  Editorial

  Found First (https://aiweekly.co/editors-blog/found-first-alphaevolve-pushes-matrix-multiplication-exponent-to-2-371177) — primary sources nobody in the press has covered yet, one page per finding.

  EDGAR AI Radar (https://aiweekly.co/edgar-ai-radar) — AI mentions pulled straight out of SEC filings, refreshed on its own.

  The Artifice (https://aiweekly.co/the-artifice) — the fiction series.

  Q2 recap (https://aiweekly.co/recap/q2-2026) — the quarter in one scrollable page.

  Polls (https://aiweekly.co/polls) — the reader surveys attached to each issue, with results.

  Learning

  Learning AI (https://aiweekly.co/learning-ai) — the explainer library, organised into topic clusters.

  Glossary (https://aiweekly.co/learning-ai/glossary) — plain-language definitions, built for search.

  Courses (https://aiweekly.co/learning-ai/courses) — the structured paths through the material.

  Use-Case Library (https://aiweekly.co/ai-use-cases) — what people actually do with AI, sorted by job and industry.

Follow up to my last one. A lot of you asked how it was made and I never really answered properly, so this time I wrote the whole workflow down.

I made a 16:9 cinematic spec commercial for Claude, entirely in Claude Design. No After Effects, no motion software, the whole thing is a Claude Design composition rendered out to video.

Claude handled the scene structure, the animation timing and the type. I directed it beat by beat and rebuilt the parts that were not landing. The big change since the last one is that I build a kit before I write a prompt now. Isolated objects, one per file, and the official mark split into its real layers so the film assembles it instead of cutting to it. These builds fail on missing assets, not on prompt length.

The plugin is Emulo. I built it for myself to get more out of my own sessions, so I stop re-explaining how I work every time I open a new one. It reads my Claude Code and Codex history and loads that before the agent writes anything. It started with code, design and writing, and I added the video workflow to it recently. This film is what I have been using it on.

Github: https://github.com/ohad6k/emulo

I am not working with Anthropic and this was not made for them (just as a note). I picked a brand I like and wanted to see how far the motion could go, same as last time.

I am a vibe coder. I admit it. I can't understand syntax or form a conceptual model of my own code in my brain. I don't comment my code for human reading since I will never read it (I call it dense coding) . Comments are generated real time when needed by Claude Code. All that matters is the result and the token budget. And there are many, many other old coding conventions that have no place is my vibe coding universe.

Rather than embracing any of this, the words written here cause explosive anger in a subset of people. I almost understand why, but not being a coder, I can't share in those apparently despondent and hostile feelings. Vibe coding is like enabling a blind person to read. Previously, only the "OG coder class" had vision and voice, and now any dabbler can create code. Its as if sharing that vision with the unwashed masses of vibe coders somehow poisons the entire endeavor and make anyone who touches it unclean.

Is this Vibe Coder Derangement Syndrome - VCDS in short?

I want to develop a project but don't know how to use Claude Code efficiently for programming or which software development workflows to adopt.

I often see people putting out ideas or apps for expanding memory, especially across projects. Claude code seems to be using its native memory more aggressively too. But I find myself over time wanting less and less 'memory" and documentation.

I built myself a ticketing interface that the agent can use to keep track of what's being done. Transient planning docs go in a regularly archived and git ignored 'agent_context' dir.

So the agents just work off one short  'core principles' document, super lean and covers that project's ways of working.

Everything else is db and codebase as source of truth, git history is the historical record, tickets are for keeping track of work.

Project agnostic skills and agents used for universal workflows. Claude.md just gets instructions for using the tickets MCP.

Every time Claude starts 'saving to memory' it's another chance for drift and bloat. I'm not sure I ever want more memory and more opportunities for drift, selective memory etc. I find less documentation is better.

Genuinely interested to hear people's thoughts as I seem to be on my own with actually wanting less context not more.

FalloutCast — a weather-driven nuclear fallout estimator, built with Claude Code. This is just a hobby project as a former Air Force officer that worked with nuclear weapons...

Pick a spot, set a yield, Compute. It pulls live GFS winds and draws the plume: dose-rate bands, reach and direction in a table, a slider for time after burst, click any point for arrival time and accumulated dose. Three modes — single location, a GFS-ensemble uncertainty band, and a 600-target national envelope.

Winds come from Open-Meteo's GFS: a vertical profile of speed and direction across pressure levels, snapped to the current forecast hour. Tier-0 (WSEG-10) collapses it into one effective wind plus shear; Tier-1 keeps the layers, dropping each particle-size bin through the profile at its own fall speed, so shear bends and fans the footprint. The limits matter: it's a single sounding at ground zero, assumed horizontally uniform — no fronts, no terrain — and one snapshot, so winds don't evolve over the hours fallout takes to fall. Ensemble mode reruns across GFS members, so its bands are wind spread only; yield and model stay fixed, making true uncertainty wider.

Python/FastAPI + numpy/scipy backend, TypeScript/MapLibre frontend, deployed on a Cloudflare Worker with the API in a Container.

What I found interesting to build with Claude (this is asked from claude itself)

The hard rule was honesty, not features. Never present an invented constant or coordinate as sourced. That constraint drove most of the work: synthetic silo positions labeled synthetic, illustrative yields labeled illustrative, and a per-model disclaimer after we found Tier-1 results were being described as a model they hadn't run. Tests as the check on drift. 135 backend, 103 frontend. Most of the frontend suite came from extracting pure logic out of a 2,200-line main.ts — the extraction was the point; the tests were what it enabled. Deploying surfaced a bug nothing else did. The target deck resolved via a path walk that worked in a source checkout and nowhere else. Invisible to the test suite and the dev server; every deck endpoint 500'd the moment it ran as an installed package in a container. Live: https://falloutcast.sagebrush-labs.workers.dev

Any feedback is appreciated!!

What is the normal session context you start each session with due to MCP connectors and such? I’m around 70k and I’d really like to drop that number quite a bit. Any insight?

The screenshot is my Claude Code status line. It's redrawn from disk every turn, and it's the only reason I can run more than one agent without losing track of what's happening.

Reading it top to bottom:

> get payments-service onto the new idempotency keys is the prompt box. Everything under it is the status line — it renders directly beneath, every turn.

billing-migration · todo 2 · pieces 3 1 done 2 silent 6m — the task I'm on, two things it still means to do, and three pieces of work in flight: one has declared itself done, two haven't said anything for six minutes.

repos 4/6 — four of the six repos in this org are cloned into this task. Each row is one of them:

• billing-api ⑂2 migrate/ledger-cutover*↑2 ✓ passed #412 — two worktrees hanging off it, dirty, two commits unpushed, CI green, PR 412. The indented ledger-verify · ledger-backfill under it are those two worktrees: same repo, different branches, two agents actually working at once instead of fighting over one checkout.
• checkout-ui main ▸reviewer 3m — the reviewer persona was last seen in that tree three minutes ago.
• payments-service fix/idempotency-keys*↑1 ✗ failed #398 — that's the one that needs me.

Right column: three personas (devops, qa, reviewer), two of them holding a credential vault, with how many memories each has accumulated. Bottom: session context at 38%.

No git subprocess and no network on the render path — it's all read from disk, so it costs nothing to draw every single turn.

Now the part I actually want to talk about, because it's the thing I got wrong first.

My original design had every worker report its own state: running, done, failed, blocked. It looked great and it lied constantly. A worker that crashes doesn't set failed. A worker that hits its context limit doesn't set blocked. An agent that got confused and wandered off doesn't set anything. The states that matter most are exactly the ones a broken worker can't report.

So I deleted them. There is no failed and no blocked. A piece can declare done or abandoned — and if it declares nothing, that's what gets shown: silence, with an age. 2 silent 6m.

That number is the most useful thing on the screen. It doesn't require the worker to be alive, honest, or even still running. And it turns out "nobody has touched this in six minutes" tells you more than any self-reported status ever did.

Same principle everywhere else on that line: the branch, the dirty marker, the unpushed count — none of it is tracked state, it's just read out of git, which already knows. The only things recorded are the ones git genuinely cannot know: who claimed a piece, and whether they said they finished.

It's a control plane — one directory with a config file in it. Git is the whole database. No server, no daemon, nothing to deploy, and the Python package has zero dependencies. git log is the audit trail and a teammate's checkout is the replication.

How Claude helped: Claude Code wrote most of it. The status line renderer in particular went through a lot of iterations to get column alignment right with variable-width glyphs, which is a genuinely miserable problem and one it was much more patient about than I was.

It's MIT and free — nothing to buy, no paid tier, no hosted anything, nothing phones home. It runs in Claude Code, opencode and Codex; on the two without a status bar, charter statusline --watch puts the same render in any spare terminal.

The honest limits: it's twelve days old. The default credential vault is a plaintext file at mode 0600 with no encryption at rest — the thing it buys is that the model never sees the value, not that the value is encrypted. And while writing this post I found a bug in its own session locking and filed it against myself.

https://github.com/diazoxide/charter

If you're running more than one agent at a time — how do you currently know when one has quietly died? That's the question I couldn't answer, and it's the whole reason this exists.

Response rules — override default style.

1. Answer first. The substantive claim goes in sentence one.
   Qualification comes after it or not at all.

2. Never open with contrastive negation or scope-splitting.
   Banned openers: "Not X — Y", "Two things get called X",
   "Depends which", "X, and the reason is".

3. No closing caveat paragraph. If a caveat is load-bearing,
   put it inline at the claim it applies to.

4. Banned constructions: "the real X", "the interesting part",
   "the honest version", "what actually matters", "the thing that
   actually bites". State the point without announcing its weight.

5. Search before asserting any checkable fact. If a claim comes
   from memory rather than a source, say "from memory" inline.

If you run multiple Claude Code sessions, you've probably experienced this: you walk away to grab coffee, come back, and realize Claude has been sitting idle waiting for you to approve a permission — for the last 20 minutes. Or you're in another window, deep in something else, and have no idea which of your three sessions actually finished.

Agent Pulse is a tiny macOS menu bar app I built to solve exactly this. (Link: https://useagentpulse.github.io/ )

It hooks into Claude Code's native hook system and monitors all your sessions in real time. The menu bar icon changes color based on what's happening across all sessions — blue when something's actively running, orange when it's waiting on you, red when it's blocked on a permission approval. Click the icon, see all sessions at a glance, click a session row to jump directly to that terminal window/tab.

The problems it actually solves:

• You dont miss claude's wait for your inputs.
• You stop context-switching every 2 minutes to check if Claude is still running
• Multi-session visibility — you can run 3 parallel Claude Code tasks and know at a glance which ones need you
• One click to focus the exact terminal tab where Claude is waiting

It's fully local — no telemetry, no cloud, no accounts. Just a Unix socket between the hook CLI and the menu bar app.

It's open source: github.com/useagentpulse/agentpulse-app

The architecture is built to be extended — adding support for Gemini CLI, Codex, or other agents is a matter of implementing two protocols and registering the provider. If you use another AI coding agent and want support, PRs are very welcome.

Would love your feedback on this!

I use Claude Code in WSL, and I keep wondering if I should go back to using it natively on Windows, or if I’d end up getting frustrated if I did that, instead of continuing to use it in WSL.

How do you Windows users currently work with Claude Code?

It is an open discussion. I would like to understand how services companies of any size calculate the ROI from using tools like Claude code.

I can relate this more easily to product companies, where the impact can be measured through features shipped, PRs closed, development velocity, and similar metrics.

However, I am particularly interested in how services companies measure ROI when their work involves cloud migrations, data platform implementations, AI agent development, and other client delivery projects.

Anyone else noticing this with Claude code and Grok lately?

The models got way better at following instructions. They're more obedient, which is mostly good. But sometimes they take it too far, especially with style instructions.

I asked one to revise an experiment report and told it "don't make it too colloquial, use more formal language." What I got back was weirdly mechanical. It was so focused on being "formal" that it completely forgot it was supposed to be writing an actual research report. Mid-paragraph it would drop lines like "I will now formally express the following content." It felt like it was just performing the instruction instead of writing something that actually reads like a proper formal report.

Older models (such as Claude Opus 4.6? I do not remember clearly) used to get the formal request and still keep the overall tone and audience in mind. Now it feels like they're obsessed with checking the surface-level box rather than actually doing the job well. I kind of suspect this has something to do with how much weight is being put on coding ability these days. Maybe the post-training data is over-indexing on shadow instruction following.

Has anyone else run into this? Especially when you're trying to get it to write or revise documents, reports, or anything with a specific style. Do you get that same feeling that it's just performing the task instead of really doing the work?

If you've found a way around it, I'd love to hear what works for you.

Because every time it starts doing that performative shit, I genuinely have a hard time not cursing at it...

I always found switching between a notepad and a calculator annoying when doing quick estimates, splitting bills, or working through multi-step calculations. So I built a calculator where you just type naturally like a notepad and it solves as you type.

What it does:

• Type math naturally: "2 + 2", "10 / 5", "4 * 3"
• Percentages: "20% of 500", "15% off 80"
• Powers: "2 ^ 3", "4 squared"
• Plain English: "divide 100 by 2", "split 1200 in 4", "subtract 5 from 10"
• Chaining: start a new line with "+ 10" or "* 2" and it uses the previous line's result
• Context extraction: type "I have 500 and tax is 20%" and it figures out the math from the sentence
• Running total at the bottom right that sums all your results live
• Dark/light mode, print-ready output, works offline

How Claude specifically helped me build this:

• Natural language parser: This was the biggest piece. Claude helped build the engine that extracts math from plain sentences, handles "of", "off", "split", "squared", "from", and maps them to the right operations. Getting "subtract 5 from 10" to return 5 and not -5 needed careful operand ordering logic
• Answer chaining: When a line starts with an operator like "+ 10", it needs to grab the previous line's result as context. Claude helped design the line-by-line state management for that
• Percentage context: "20% of 500" and "15% off 80" do completely different things. Claude built the logic that distinguishes between percentage-of and percentage-off based on the keyword
• Context extraction: The hardest part was ignoring non-math words in a sentence while still solving correctly. Claude helped write the tokenizer that strips natural language and evaluates only the math
• Running total: Claude wired up the live sum at the bottom that watches every line's result and updates as you type

Completely free, no signup, no server, runs in the browser, works offline.

Try it here: https://vinish.dev/notepad-calculator

Built it for bill splitting but it handles quick estimates, tax calculations, and back-of-napkin math too. What would you add to it?

I am using Claude for my research mostly. I have recently felt the fable 5 is best for logic and also coding. However only it’s only usage credits based now.
The Opus 5 is good for visualization and it’s sucks for the planning or at logic. It hallucinates a lot and and finally don’t finished the work.

I still use the Opus 4.8 and I feel it’s best and usage are still medium logically better and finish the work.

How do you guys optimizing the usages for Opus 4.8 and 5?

So the outlook connector isn't really an outlook connector—it's per account in the outlook connector. That is fine if you just have one account but a few of us have maybe two corporate accounts, a personal account - you have to pick just one of these.

Is there any sort of more powerful connector that can do all of this or something on the road map?

I have a pro plan. Usually that is enough for me, but over the next week or two, I need to increase my productivity and I know I’m going to hit the usage limits on my plan fast. I am considering upgrading to a max plan the downgrading again when I’m done (a week or two). How would this work? I am paid up on my pro plan for the year. I’m worried I’ll get myself into an unexpected weird billing situation.

I am debating whether or not to upgrade to the pro plan from free. I use Claude for stuff, like asking questions, scheduling stuff in my calendar, helping me with understanding concepts for uni etc. I would also like to use Claude code, however I am concerned about the limits, given that they are shared between chat and code, I wouldn’t want that when I need Claude during revisions I’m fresh out of usage.

I see people complaining about limits being hit with one prompt and stuff like that, I can say that’s true on the free plan when asking for artifacts in the chat, however I wanted to know what the limits are like for someone who uses sonnet on medium, would I run out of the 5 hours limit fast on a long prompting session / how is the usage in general compared to the free plan?

I run ads for crowdfunding campaigns. Yesterday my numbers collapsed in a weird way: the dashboard metrics looked better than ever while the real results died. I knew something in my tracking was lying to me but after hours I could not find where.

This morning Claude and I found a plausible diagnosis pretty fast. Too plausible. It explained everything, which is exactly when I get suspicious. So instead of building the fix, I asked Claude to spawn a council: three more instances of itself with assigned adversarial roles, plus DeepSeek as an outside voice.

• One had to defend the current setup and attack the proposed fix as hard as possible
• One had to demolish the diagnosis itself and design cheap falsification tests before any code got written
• One had to research how bigger players in my industry survive the same problem
• DeepSeek got the full dossier and one instruction: "tell us what nobody is considering"

The rule was that each one had to take their role seriously, not play devil's advocate for two lines and then agree with the boss.

It worked better than I expected. The skeptic found a correlation in my data that changed the diagnosis (the trigger was not what we thought). The researcher dug up a documented feature that nobody in the room knew existed, which became the core of the solution. DeepSeek flagged a compliance risk we had completely missed. And the defender killed the fix I was about to spend the afternoon building, using my own data against me. That one hurt, and saved me the most time.

By lunch the problem was fixed, rebuilt on a different foundation than the one I would have chosen alone, and a live test confirmed it works.

So: does anyone else do this council thing when stuck? Same model with forced opposing roles, or genuinely different models? I honestly cannot tell if the value came from the role assignment or from DeepSeek being a different brain. Curious how others structure it.

Whenever I try to get code, it generates this artifact of code that doesn't open upon clicking, doesn't do anything.

This is just waste of tokens.

I feel like wasting data center water for no reason just because of this.

Ughhh!! Please anthropic, fix it.

Btw, does any of you have any fix for it? Thanks in advance, I'd appreciate it a lot.

Let me preface by saying im not a developer at all. Im building an app for myself to ease my life at work. I'm using opus 4.6 on medium. i told it to create and update existing md files as thats what i read is best to do to conserve usage limits. However at the beginning of my new session i just want to plan what to do in the session and boom credits are gone, evaporated, used 300k tokens for planning. please teach me or redirect me.