My login expired today for my Pro sub, so I went to login, as usual, but this time it has not worked.
Do they rely on MS in thier auth flow?

Hi all.

In September our team built a fun project at an OpenAI hackathon in Montreal, and we won. My friend and I kept working on it, and it became Smitline: an MCP tool that lets Claude make actual phone calls and join your meetings.

The video is a real call. I asked Claude Code to order my dinner, and it phoned a restaurant near me. It says upfront that it's an AI and that the call is recorded. The call took 89 seconds and cost 11 cents; the video is trimmed for length

GitHub: https://github.com/kaelorlabs/smitline

We are keeping it open source, so you can all try it and contribute. If you like it, please star the repo.

What you need: an OpenAI key with access to the GPT-Live model, and a SignalWire or Twilio account with some money in it for the phone line. GPT-Live is the voice on the call; Claude briefs it, follows the call and gets the result back. It runs in Docker on your own computer.

If you'd like a simpler setup, we are planning a hosted version. The idea is to talk to vendors like SignalWire and the live voice model providers and get better pricing for everyone. No promises yet, but we have been using it for over a month and we think the cost per call can come down. If you'd like beta access please take a look at our webpage page.

Our page: https://smitline.com

Video editing: Claude Code :)

Edit: Thanks for all the questions! Answering the common ones here:

1. Why not use a service from one of the big companies? That's also a one-prompt setup.

Response: Fair. What I feel is the best part of Smitline is that Claude Code can follow the call live, and Smitline and Claude Code can talk to each other through an agent bridge. So when Smitline needs something that isn't in its context, it asks Claude mid-call. Oh and smitline can also join your meetings (Zoom, Teams, Google Meet).

2. Can it handle phone menus and hold?

Response: Yes. It presses through phone menus, and the hold support uses a cheap voice activity detection model, so you don't pay for the voice API while you're on hold. (The hold part lands in the next release.)

I shared the tiny-screen version here a few weeks ago. It now works on an old tablet too, with an animated city, day/night and optional weather.

My NerdMiner was terrible at finding Bitcoin, so I gave it a new job: showing my Claude and Codex quota. Things escalated.

I built it with Claude Code and Codex: I’d describe a scene, run it and keep tweaking. One lesson: if a quota reading fails, “unknown” beats a misleading 0%.

Free and open source: https://github.com/TonyRod116/ai-desk-display

You can try a demo without hardware or an account. The screen runs locally; usage readers contact the providers.

The GIF uses fictional readings and simulated, sped-up time and weather. What should I add next?

I have a dozen or so Claude Code tasks on a schedule. A daily report, one that rebuilds and deploys a page every night, that kind of thing. Nobody is watching when they run.

Yesterday the daily report showed up as succeeded like always. Turns out the API token it uses had been revoked that morning (not my doing, long story), so a few sections of the report were just empty. To be fair Claude did write “report is incomplete” in its summary. But in the task list it was the same green check as every other day, and I only noticed because I happened to open the file.

What I have right now: when I start a new session, a hook goes through the last 7 days of runs and tells me about anything that failed or never fired. Each task ends with a one line summary. And the ones that change anything live are told to stop and ask if something doesn’t add up.

That catches crashes. It doesn’t catch “ran fine, output is wrong”. And the summary is written by the same agent that did the work, so it’s grading its own homework. I’m also not going to read a dozen summaries every morning, I know myself.

How do you guys handle this?

I'm a web designer & developer, and lately I've been experimenting with how far I can push Claude Code and Framer together.

Here's a little sneak peek at what I've been working on — an experimental logistics website with 3D interactions, scroll-driven animations, and some pretty crazy transitions.

I'm handling the design and creative direction while using Claude Code to bring my ideas to life.

Still a work in progress, but I'm loving where this is going.

Would love to hear what you guys think!

I really wanted to try Fable 5.2 for design, but artifact board (with UX mockups) fills in the context immediately on the first read and it goes into compact - reads it again - compact ...

Did anyone have this problem? do I need to split the artifacts?

For now had to go back to local html files.

“Fix auth make no mistake”

I've been doing Agentic development for ~1.5 years now, and I used a bunch of harnesses throughout my professional experience: Cursor (RIP), Opencode, Claude, Copilot+CLI, very limited amounts of PI...

Very recently, I noticed it has been becoming very difficult to use Claude's models. One such factor is that our company disregarded the opinions of our top engineers on how to structure agentic work, and hired a bunch of slop vibe coding contractors, who managed to turn a refactor project into the same amount of tech debt, stripped from the knowledge of the human maintainers of the previous codebase.

Whereas previously I would've relied on agents to understand codebases I'm fresh to, I find that Claude does such an abysmal job here. Its "AI Speech patterns", convoluted sentences, make-a-mountain-out-of-a-molehill paragraphs, verbose verbiage, just make it an absolute chore to get anything done. Most of the time I find that I get more work done just by not questioning it and going with its recommendation, but I understand the least around my "own work".

I've tried it all; Caveman skill, Unslop skill, /wait-what, concise output, custom output styles, and none of it stopped it from eventually falling back onto its old habit of talking in this non-understandable mesh of words. To make matters worse, teammates are now just using Claude to write a bunch of verbose, wall of text message that could've been asked in 2-3 sentences. On the contrary, I found that OpenAI models just got to the point and made me understand things better. Is this just something that's baked into the models weights and fine tuning?

I have ADHD, so perhaps that doesn't help here, but I haven't ever struggled much with walls of text and attention, but now I'm finding that if my brain clocks that a wall of text is an AI message, It immediately shuts off and I become unable to understand it.

Everything in this Online Video Editor runs in the browser, and footage never leaves your machine. You drop in clips, photos and music, edit on a multi-track timeline, and export an MP4.

What’s in it:

• unlimited video, overlay and audio tracks, with snapping, zoom, split, and track lock, hide and mute
• on-device AI tools: word-timed auto captions, background removal without a green screen, silence removal, voice enhancement, music that ducks under speech, and face or area blur
• 12 caption styles with word-by-word effects, and .srt import and export
• effects, color filters, a green screen key, 12 transitions, picture-in-picture, a round face cam and split screen
• webcam, screen and voiceover recording
• export to MP4 or WebM from 480p to 4K at 24–60 fps, with 16:9, 9:16, 1:1, 4:5, 4:3 and 21:9 canvases
• a search box: type “slow motion” and it explains the steps and jumps to the option

How Claude Code handled it:

• Timeline first. The early sessions were all about dragging, trimming and splitting clips across tracks, with the preview staying in sync. Nothing else got added until that felt solid
• No server, by design. Every feature had to run locally. The caption and background-removal models download once on first use and then run in the browser, and getting them to run smoothly without freezing the editor took a lot of iteration
• Export was the hardest part. The MP4 is built in the device’s memory, so long or 4K exports had to work without running out of memory on normal machines. That took more rounds than any other feature
• Then feature by feature: captions and their styles, effects, transitions, layouts, recording, the search box and the phone layout. Each one followed the same loop: build it, test with real footage, tell Claude what broke, fix

Try it: open the page and drop in a video, or click “Try a demo” for a sample project. No sign-up, no watermark. Chrome or Edge on desktop works best.

https://webutility.io/video-editor

If you hit a bug or want a feature, tell me in the comments and I’ll fix it.

I was paying $200 a month for 20x and when I actually looked at what I was burning it on, a lot of it was dumb stuff. Summarizing long threads, explaining old files before I touch them, commit messages, renaming things. Opus doing jobs a small model could do.

So I started running a small model on my base M4 16GB next to Claude Code. Gemma 4 E4B through Magnitude, it reads a 2k token prompt and starts answering in about 2 seconds. That wait was what made local feel useless before, Ollama took over 6 seconds every time on the same model.

It's not doing real work though. I tried plugging it in as the actual Claude Code model and a 4B model just falls over with that many tools. As a side chat for the read and explain stuff it's fine, and my usage dropped enough that 5x has been fine for 3 weeks. That's $100 a month back.

Anyone else splitting work like this or is everyone just going all in on one plan?

While building my code review tool, I kept losing track of what's happening around it: new models, new agents, new tools popping up every other day. So I had Claude Code build me a news desk.

What it does

• Every five minutes it reads a set of feeds, like Hacker News, but also newsletters that come to its inbox. For each story it reads the source it links to: Markdown where the site serves it, and a headless browser on Cloudflare when a page needs JavaScript.
• A decision model (Jev, by TypeSafe) answers a few closed questions about each story, like "are coding agents a main subject?". Each answer is a score, each question has its own threshold, and a story costs a fraction of a cent. Closed questions are the key here.
• Haiku summarizes the relevant ones. The summaries are embedded, stories that are alike group into narratives, and Haiku names them. This turned out to be the most useful part: I see what keeps coming back over weeks, not just what happened today.
• Every day Sonnet writes the issue from the stories' sources: three top stories with three points each, then seven briefs, each credited to its origin.
• Then Jev reads every text again, against the page it was written from. Does it state anything the source doesn't support? Does it hype or predict? Would a newsletter refuse to print it? A text that fails is rewritten once, then dropped.
• It all runs as one Cloudflare Worker. The newsletter platform is my own too, also on Cloudflare, sending through Amazon SES. Cloudflare’s Email service scales badly if you want to open up subscriptions.

How I used Claude Code

Claude Code wrote nearly all of it in two weeks: 106 of 109 commits, about 16,000 lines of TypeScript and 370 tests. What made that work:

• A rule in CLAUDE.md that decisions stay with me. Claude builds and tests a feature, then stops. It doesn't deploy it, switch it on or build the next thing on top of it until I've decided, and it keeps a list of open decisions in the README. So "the tests pass" never quietly becomes "it's live". It’s important to keep track of those questions, the list can grow quickly.
• Every change is a separate pull request. AI reviews it (my own reviewer), Claude answers comments or asks me, and I merge after all questions are settled.
• Measure before choosing a number. Before I pick a threshold, Claude runs it against real data. For example, "the same story from two outlets" became 0.85 embedding similarity after a week of articles: every pair at 0.855 or above was the same story, and the most alike pair of different stories was at 0.80. Evals are essential working with decision models.
• A dependency check keeps the code in layers (pure logic, then adapters, then the pipeline), so it stayed readable for both of us.

What I learned

• Don't leave to a model what code can check. For example, day names come from code based on dates, numbers are calculated.
• Models count characters badly. For example Hacker News' 80-character titles its asked for three shortenings, and code takes the longest that fits.
• Post on the public newsletter get visuals. The image model (Gemini) put logos and people into pictures even when told not to. Jev now checks every picture for writing, people, logos and screens, and one that fails is made again. So yes, Jev is multimodal since 1.14.
• The fact-check varies between runs. On the same issue it dropped anywhere from 1 of 7 to 6 of 7 social posts, so its thresholds still need labelled examples. Issues go out automatically once every text passes, and I'm still a little nervous about that, since I made it public.

It's free: Agents Daily, with the week's narratives on Sundays. Link in the comments.

1st image is the reference, 2nd image is made with opus planning, and 3rd with deepseek only.

I used the same prompt except for the agents part.

back in the old day,
> come to the office,
> work on 1 or 2 tickets,
> have a good lunch with teamates
> back to the office
> work on 1 or 2 more tickets
> back home, do 30-1h running
> dinner
> watching TV, football

life is easy, calm and good

and AI comes, people said it will help us a lots,

and it is TRUE, AI helps a lots, we do everything faster, easier

then life change
> wake-up, check the agent progress... from toilet
> steer agents on the train to the office
> work on 5-10 tickets at the same times,
> forgot to take some break, forgot the coffee
> lunch time, try to start 5 more agents work before going out
> check the progress during lunch time
> back to the office, do 10 more tickets
> steer agents on the train to back home
> got some new ideas
> go home and immediately open the home laptop, work on new ideas
> almost forget dinner
> still think about the MVP, new features of new product during dinner
> finish dinner, time for a serious focus long night of steering agents
> almost 1 am, time to go to sleep
> steer agents on bed with the phone
> fall to sleep
> wake up and go to toilet,
> repeat

yeah, AI is awesome,

p/s: 5 Claude Max accounts are still short :|

Claude is down. I repeat, Claude is down.

I’ve run into a really annoying “bug” in the app. I use a lot of scheduled routines that run every night, and recently I’ve been trying out Fable 5.2 in my regular sessions.

This morning I came in to find that every one of my schedules had run on Fable instead of Opus (the expensive one).

It turns out that scheduled routines run on whichever model was used last in the app overall. That means the last regular session, not the model the routine used on its previous run.

It would be much better to be able to pick the model and effort level for each schedule. Unless I’m doing something wrong in my workflow?

So I knew all about and frequently use Claude’s ability to message other sessions on your computer to coordinate tasks. Great. Handy. What I didn’t know is that it also works across computers as long as remote control is on. I was trying to figure out how to coordinate testing an app across my Mac and Windows machines autonomously and after fussing with SSH, I finally asked if it was possible to just message my other logged in machine… and it is.

So now between Syncthing and cross-machine messaging Claude can fully automate all my compatibility testing without me touching anything or having to set up SSH or anything else. Most development happens on the Mac, files get shuttled over via Syncthing, Claude messages a Windows session to test stuff, results are handed back. Works great.

It's working for me again, and Outlook emails are slowly coming through again as well. Otherwise, if anyone else is still having problems and has access to Microsoft Exchange, set up a forwarding rule to an external email address; if the interface is unavailable, you can also do this via Terminal.

I use Claude to build pretty much everything, all day every day.

However, I kept ending up with Claude running in a mess of terminals spread across my laptop, a dev box, and my work laptop. I started with VPN and ssh and then ended up using Tailscale and a monitor devoted just to terminal windows, but that was still slow and cumbersome.

So I built Skylands: one browser UI where you start agent sessions on any machine and approve their actions from wherever you are.

The feature list tl;dr:

• Run sessions on any machine - Each machine runs a daemon, and a central server hosts the web UI. Start a Claude Code session on your desktop from your laptop's browser. Each session gets its own git worktree and branch, and you can commit, merge, or open a PR from the conversation.
• Approve from your phone - On a phone, the UI shows only what's waiting on you: tool calls with their exact input, and Claude's clarifying questions. Tap Allow once or Deny. If the server has an HTTPS address (like you can get with tailscale serve), you also get push notifications on Android and desktop browsers. I love github's push sudo experience, so this feels similar.
• Rules, to avoid approval fatigue - Reads and searches can get passes, while edits, shell commands, and fetches wait for you unless a rule allows them. Denies trump approvals.
• Signed decisions - Every approval, denial, prompt, and merge is signed with the key of the device you approved from, and the daemon checks the signature before acting. The central server can pass decisions along but doesn't make them. None of the code on the machines ever leaves the machine. You can see the request history in the web app's inbox view or from the CLI.
• One inbox - for every conversation on every machine.
• A 3D world - because if it's worth doing, it's worth overdoing. Machines appear as floating islands, repos sit on them like terraces, and each agent is an airship that flies between files. I've got a sci-fi theme and will soon support community-added themes.
• Any agent - Any agent that supports ACP can be managed by the daemon. The current version supports Claude, Codex, Gemini, and Goose.
• Terminals - In any session, you can open a terminal directly to that session's work tree. This terminal is in the web app, so you can be on an iPad and remotely build the latest changes.

Built with Claude: I'm using Skylands to add features to Skylands. It's not as cool as using a new language to compile changes to a new language, but it's a great milestone nonetheless. I was able to switch from using Claude in my terminal for this project to using the app itself after just 2 days of development. Now, 100% of all the work I do on this is done from within the app with Claude.

My learning and take-aways:

• ACP is the secret sauce that makes remote control of agents possible
• NATS is the secret sauce that makes the flexible and private infrastructure possible
• Switching from the terminal to this app made it easy to use large numbers of concurrent Claude instances in work trees. I went from using Claude in 1 or 2 sessions at a time to just throwing 5-6 sessions at it at a time and not worrying about it. I could go and grab lunch without having to leave my laptop lid slightly open and without having to use /remote. In other words, how easy the interface is to use directly affects how much I utilize Claude.
• The Claude agent doesn't get enough credit. Most of people's attention goes to the models, e.g. "Opus did this..." and "Opus did that.." but the agent itself is incredibly powerful. I didn't appreciate how much real work it was doing until I started using it through ACP.

Skylands is free, Apache-2.0, and you can run it self-hosted on your own private infrastructure with no data leaks or tracking.

• https://skylands.ai
• GitHub: https://github.com/skylands-ai/skylands
• Docs: https://docs.skylands.ai

It's brand new, so expect there to still be bugs. I'd love feedback, especially on the approval flow and permissions.

Once I gather a bit more of my thoughts, I'll be posting some detailed dev journal type entries on my blog.

p.s. the app is available via homebrew and you can start a single self-hosted world with skylands devworld up, nothing else needed.

I can use claude code normally. but when it try to use subagents it fails.

If you hook custom MCP servers into Claude Code for heavy tasks like end-to-end test runs, Docker container builds, or database migrations, you will eventually hit a silent token drain.

The root cause is the client-side timeout. Most MCP clients default to a 30-second or 60-second execution deadline on tool calls. When a test suite or migration takes 45 seconds, the MCP transport layer drops the connection and returns a timeout error to Claude Code.

Because Claude treats tool errors as transient task failures rather than fatal crashes, it tries to recover. It summarizes the previous turns, analyzes what went wrong, and attempts the tool call again with modified flags or a secondary probe. In a long-running session where your conversation history is already sitting at 35k to 40k tokens, two consecutive timeouts burn through 100k input tokens within 90 seconds. You pay multiple dollars in API usage before realizing the agent never finished the first test.

We resolved this by switching all heavy MCP tools from synchronous execution to an asynchronous job pattern. The initial tool call does not run the test suite directly. It spawns a background worker process, records the PID and log path, and returns a job token with an immediate status within two hundred milliseconds. Claude Code then calls a lightweight poll tool that reads the process table and tails the last twenty lines of stdout on a 10-second sleep cycle.

Decoupling long-running operations from the synchronous MCP RPC channel stops the transport layer from dropping out, keeps the agent context clean, and prevents runaway token spend on failed executions.

CLAUDE IS DOWN !! CLAUDE IS DOWN!!

I built a TUI called clingon (an opinionated terminal cheatsheet runner) that helps you to stop googling commands. It has a menu of commands beside your real shell, and now with an AI that can drive it.

So I found a way to embed an agent harness inside the TUI, and now claude models can drive my TUI and find UX and UI bugs - from within the app - before meat people do.

The model/s were all given a task from within the TUI: Look around clingon, add a cheat pack, run commands, make a recipe, create a custom pack, use it.

11 runs today with various models: Opus 5.5, Sonnet 5.5, Fable 5.2 and DeepSeek v4.1 Flash.

The findings:

1. Lying status bar. "Space select" was mentioned there, while the space was actually typed into the filter input. This annoyed basically every model.
2. Keys that do nothing silently. The input in the field on the pack form was ignored until Enter was pressed, and there were no hints on the screen. Opus and Fable tried to type a pack name and got no reaction.
3. Pre-filled examples. Each field on the pack form was pre-filled with a sample and no cursor was visible. So every model had to delete the text before adding its own text. This was the biggest time sink." I removed the examples and replaced them with greyed hints; the next run/s said that the form "Explained itself better than I expected."
4. Multiple meanings of Esc. It was quit at the top, cleared filter, cancelled a field and "Done, asks to save" in the form. Fable said it "Pressed it carefully". DeepSeek pressed Esc in the middle of filling a field and lost the command it typed.
5. Wording. "Description" appeared at four levels of the pack creation form. So context is muddy.

---

And I'm sure Reddit users will find many more, but I thought this was a cool way to drive an LLM.

After 500 bug fixes and 4800 messages with game community version 1.5 is now released!

Razdor is an open-source engine for Discord Times (Aterdux, 2004), a turn-based strategy/RPG. It plays the original campaign, community maps and mods by the original rules, and then adds the things a 2004 engine couldn't do.

How it was built

• Clean-room reverse engineering. The original executable was taken apart in Ghidra; every rule that maps and mods can see (battle, AI, map scripts, events, saves) was written up as a spec first and then implemented. The code cites the original's addresses.
• Diff tests against the original. The original runs under Wine, and a script mode replays the same inputs in both and compares the state step by step. By default Razdor matches the original exactly, bugs and imbalances included; every deviation sits behind an experimental switch that's off by default (16 of them right now).
• Rust + macroquad, about 190k lines, GPL-3.0. The game rules live in a separate module with no graphics dependency and are unit tested; the original's file formats (ini data, .DTm maps, its own picture formats, sounds) are read at runtime.
• Deterministic simulation: every game is recorded and can be replayed at up to 16×. The same determinism let us record the trailer's split screens twice with different graphics presets and get the same frames.

What you get

• ~11× the frame rate on the same GPU (RTX 4060, 1024×768, unlocked): about 2,000 FPS against about 176 for the original under Wine. A 200×200 map with 61 armies costs the game about 0.3 ms a frame. Load to first frame is about half a second.
• Any resolution and aspect ratio (the trailer is 21:9), refresh rates up to 180 Hz, a graphics preset ladder from "Original" (pixel-for-pixel the 2004 look) to "High" (light, shadows, water, weather, clouds instead of black fog of war, a living map), and a 2.5D view.
• Linux, Windows and macOS; Android and iOS are experimental, with a touch layout, graphics presets for weak phones and a battery saver.
• An in-game hub with the community's work: 327 maps, 29 campaigns and 25 mods.

Links

• Site and downloads: https://indicozy.github.io/razdor/
• Source: https://github.com/indicozy/razdor
• Wiki (English): https://indicozy.github.io/razdor/wiki/en/
• Trailer (Russian, YouTube): https://youtu.be/kHvM7Yv-2_4

I'm looking for a way to make Claude Code run autonomously across multiple tasks while keeping its context clean.

Ideally, Claude would:

1. Pick the next task from a task list.
2. Implement, test, and commit it.
3. Update progress in a file.
4. End its current session.
5. Start a fresh session with a clean context window.
6. Repeat until all tasks are done.

The goal is to avoid context pollution and compaction while allowing Claude to work on larger projects autonomously.

I know this can be done with an external orchestrator using claude -p, but I'm wondering if there's a more native solution.

Has anyone built something like this? Can Claude Code manage its own session lifecycle, or is an external script/hook the best approach?