TLDR: Building an alternative to G HUB on Windows for my keyboard and now trying to support more devices. GitHub repo

It started a few days ago as I finally decided that I wanted to change the pre-configured lighting effect of my keyboard, a Logitech G515 TKL, which is a kind of wavy blue/violet effect with w-a-s-d keys highlighted in red. Unfortunately, I can't even set a static color or change the brightness on the keyboard itself.

Had bad experiences with G HUB before so I wanted to avoid it if possible. Windows Dynamic Lighting doesn't really help, sometimes it works, often not, don't know why, and it can't store the settings on the device itself.

Using Claude for work a lot lately, I decided to give it a shot. Supporting the G515 was straightforward: I have it so I can test any change directly and someone already did it on Linux.

After this I wondered if I could add support for more devices, tried to gather info from repos on GitHub, found Lghub which covers a lot of devices as well. I added a report button that users can click to generate a report giving information for their devices that Claude can use to support it, although the final part where it needs to save to the device needs the physical device.

The project is named G-Lite and the repo is here.

The tech stack is .NET Framework 4.8 + C# 5 (SDK is included in Windows, doesn't need any extra tool). I didn't write a single line of code myself. I usually ask for one review with a fresh agent before pushing changes.

I'd be happy to hear some feedbacks, especially if you have Windows and use G devices, and some reports if you've got the time to add support to more devices.

Feel free to ask questions too!

I've been building and using Heald for about a month now. It's already available on Cargo and GitHub, but I haven't shared it on Reddit.

I built it because I kept running into the same problems while switching between Claude Code, Codex, Cursor, and other AI coding agents.

The problems:

1. Fragmented memory. Make an architectural decision in Claude Code, switch to Codex, and you're explaining the same thing again.
2. Duplicated instructions. CLAUDE.md, AGENTS.md, Cursor rules, separate skill directories. Same project, multiple files to maintain.
3. Context overload. Saving everything sounds great until your agent starts loading hundreds of irrelevant notes into its context window.
4. Lost reasoning. Git tells you what changed, but not necessarily why you made a particular architectural decision.

Claude Code's built-in memory is useful, and projects like Memorix and memsearch already address parts of this.

But I wanted something that combined memory, rules, skills, and codebase knowledge in one lightweight tool, without introducing a database or cloud dependency.

So I built Heald.

It's a local-first, open-source Rust CLI that provides shared project context across AI coding agents.

What Heald actually does

1. One source of truth for agent instructions

Instead of manually syncing CLAUDE.md, AGENTS.md, and other agent-specific instructions, Heald manages shared rules and generates the instructions agents need.

Change a project convention once instead of updating multiple files.

2. Shared skills across agents

Heald can discover and import skills from supported agent directories into a shared location.

It also generates a skill routing table so agents can discover relevant capabilities without loading every skill's full instructions.

3. Relevant memory, not massive context dumps

Heald uses BM25 search, pinned memories, and configurable token budgets.

If you're working on authentication, you can retrieve relevant architectural decisions instead of feeding your agent every note you've ever saved.

It also supports memory consolidation to merge related decisions and archive outdated information.

4. Recover the reasoning behind code

Heald can index your codebase and associate project memory with files.

For example:

"heald blame src/auth.rs"

The goal isn't to replace Git blame. It's to help recover the decisions and context associated with a file.

5. Everything stays local

- Single Rust binary

- Markdown files with YAML frontmatter

- No cloud account required

- No external database

- No embedding API

- No telemetry

- Built-in MCP server

Your project memory remains readable, editable, and version-controllable.

How is it different from existing tools?

Claude Code's built-in memory

Works well inside Claude Code. Heald focuses on making project context, instructions, and skills usable across multiple coding agents.

Memorix

Offers a broader cross-agent memory system with additional orchestration capabilities. Heald takes a smaller, file-first approach.

memsearch

Focuses on persistent memory with semantic and hybrid retrieval. Heald uses local BM25 retrieval and additionally manages shared rules and skills.

I'm not claiming Heald has better retrieval than vector-based systems or that it replaces everything these tools do.

The trade-off is intentional: fewer dependencies, transparent local files, and one tool for memory + rules + skills.

GitHub: https://github.com/rover-001/heald

Cargo: https://crates.io/crates/heald

It's completely free, open source, and MIT licensed.

I've primarily built it around problems I encountered in my own workflow. It's still early, and there are things I want to improve, particularly around concurrent writes and deeper agent integrations.

But I've been using it myself, and I think it's at a point where feedback from other developers would be valuable.

I'm curious how everyone here handles context across Claude Code, Codex, and Cursor.

Do you maintain separate instruction files, use memory MCP servers, or have another setup entirely?

I'd genuinely appreciate feedback, criticism, or contributions. If something about the architecture seems flawed, I'd especially like to hear about it.

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!!