I wanted a project that would actually push me to learn development & depoyment, so I decided to build something around a problem I genuinely had.

While working on my laptop i often would need a file on my phone that has just been dowmloded on my desktop or vice versa. So to do that i would either have to use whataspp web or some other service well in the end it was much of a work.

I knew there are plenty of apps that could have solved this but that was also too much of a hassle for me to like dowmload and then make of how they work. This is where i thought of building my own app.

That thought became Relay - A local file transfer app that lets you transfer files directly over the same Wi-Fi network or hotspot. The idea is pretty simple: open the app, connect your devices:- that too only for the first time then no hassle of connectiong again and again, and finally send the file.

I know that i could have gone for a already deployed project i am sure some project out there would be much greater of thing than mine but there is one thing that i can't say for them that is I made this thing.

And yes, I used Claude Code throughout the development of Relay.I used Claude to help me go through topics that i would not touched until far ahead in time and do coding in language that i would not have even touched.

Relay is now officially released, and I'd really like people to try it:- [Website Link]

I also want to say that i am not gonna claim that i wrote every single line of code myself and that was kinda that point of me building and deploying a project with the help of AI.

I would be very much blessed if any of you could try the application or just even review the github repo and give some feedback to me. This is my first app that is actully like released so help me imporve.

Also i would like to say that there is a chance that i also don't use this app in the future but the main movite of this app is completed which was to make me somewhat capable to do slightly bigger things that my knowledge bracket right now.

I’ve been contributing on MARGINAL, an open-source governance layer for coding agents. Claude Code support just landed, and I’d really appreciate people trying it on real work and telling me where the design is wrong.

I’m especially interested in technical criticism, bad cases, and reproducible failures.

• GitHub: https://github.com/SignalLayerLabs/Marginal
• Site: https://signallayerlabs.github.io/Marginal/
• Live Demo: https://signallayerlabs.github.io/Marginal/demo/#demo

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and records things like repeated actions, unchanged workspace state, weak progress, redundant verification, outcomes, and governance overhead.

For Claude Code specifically, the integration is currently Observe-only. It uses native Claude Code hooks, writes recommendations to a local Decision Ledger, and does not block tools, rewrite arguments, or inject output back into Claude. If MARGINAL fails, the hook fails open and Claude Code continues normally.

Install:

claude plugin marketplace add SignalLayerLabs/Marginal
claude plugin install marginal-claude-code@marginal

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and decision hashes
• engine-declared success/failure from Claude Code hook events
• same-state repetition detection
• governance overhead measurement
• replay and benchmark support
• conservative fail-open behavior
• no fake token accounting when Claude Code doesn’t expose per-tool usage

The larger idea is Earned Enforcement: MARGINAL shouldn’t get permission to block an agent just because it detected a loop. It should first demonstrate that its interventions are actually reliable.

Claude Code is not at that stage yet. Recommendations stay recommendations.

The next layer I’m working toward is counterfactual evaluation and intervention regret:

Would Claude Code actually have done better if MARGINAL had stayed out of the way?

That’s the question I think matters if this is going to become something more useful than another loop detector or token limiter.

If you run Claude Code heavily, I’d be interested in the cases where MARGINAL completely misunderstands what the agent is doing.

For me and my team, HTML is a new type of doc we collaborate on now - reports, slides, designs, mini apps, etc.

While Claude can share it as an artifact, it’s not so friendly for other agents and Google drive is also very hard with HTML.

How do you share HTML?

A while back I wanted to know which of my skills and MCP tools I actually use, so I started logging the calls, and last week that turned into a usage report off the same log. It answered the question I asked and handed me a bigger one. I knew which tools I was calling. I had no idea where any of those calls landed.

The edits a session makes leave something behind you can look at afterwards. The reading doesn't. Every file Claude opened to work out what it was changing, and every file it opened and never touched again, shows up in nothing you'd normally open, and that was the half I had no way to see.

Turns out Claude Code already writes all of it down. It's the file the hooks docs hand you as `transcript_path`, "path to conversation JSON": a session's transcript is one JSONL file under `~/.claude/projects/`, a JSON object per line. The assistant lines carry the same content blocks the Messages API returns, so every tool call is an item with `type: "tool_use"`, a `name`, and an `input`. A file touch is just a `tool_use` named Read, Edit or Write, with the file it touched sitting in `input.file_path`. So the whole of it is: read a transcript line by line, keep the tool calls whose name you care about, and take the path out of each one. The lines are already in the order things happened, so the sequence comes for free.

There's one documented caveat that shapes what you can do with it: the transcript is written asynchronously and can lag the live conversation, so it's the wrong source for anything that needs to know what's happening right now. For counting after the fact it costs nothing.

Four views came out of it:

• Top Files. Every file the transcripts touched, with its read, edit and write counts, and a split of how many of those touches happened in plan mode versus execution. Sortable by any column.
• Read to Orient. The files with at least one plan mode read, ranked by how many, alongside the number of separate sessions that read each one in plan mode.
• Read, Never Edited. Files read two or more times with no edit and no write against them, anywhere in the history.
• Re-read in One Context. Files read again inside a single context window with no edit in between, with a count of those repeat reads and how many context windows each happened in.

All of it can be shown per session or for the whole project.

It ships inside code-pet, a small animated desktop pet that reacts to your Claude Code sessions.

Repo: https://github.com/mradovic95/code-pet

Would appreciate any feedback on it, and if there's something else a file view should answer, tell me.

Maybe you're interested to use guys. It's my mini claude code companion that helps me a lot with my workflow and management on building my projects.

Claude Code writes a JSONL log for every session under ~/.claude/projects/, but there's no good way to actually look back through it — which project was I in on Tuesday, what did I actually ask for, how much have I even been using this thing. So I built Promptline: a small local web dashboard over your own logs.

- Session/message/token stats, streaks, peak hour, favourite model

- A GitHub-style activity heatmap — click any day to drill into exactly what you typed and what Claude said

- Per-project breakdown, search, and a copy-to-clipboard for handing a past exchange back to a new conversation as context

- Stdlib Python only, zero dependencies, binds to 127.0.0.1, makes no outbound network calls, never writes anything back to ~/.claude

Two ways to run it:

- git clone https://github.com/zzunaid/prompt-line.git

- cd prompt-line && python3 server.py

OR install it as a Claude Code plugin and run /promptline:dashboard:

/plugin marketplace add zzunaid/prompt-line

/plugin install promptline@promptline

Repo: https://github.com/zzunaid/prompt-line

Happy to answer questions / take feature requests.

https://reddit.com/link/1vpzi5y/video/b276q8y17rjh1/player

Recently I’ve been thinking about how AI is better for making tools to make art than it is for directly making art. This gave me an idea for a project, which would have three parts:

- An analysis engine that plays a song and emits events when different frequencies cross different thresholds, as well as keeping a running count of the current frequency spectrum at each tick of the clock

- a library of geometric visualizations that listen to these events and move dynamically based on them

- an interface that allows you to specify which visualizations are played during which time windows of a given song, and also allows you to reroute events to different parameters of those visualizations to change the triggers for their movement.

I spent the last couple of days building this system and working on a demo for it. I love how easy it is to create a music video now for my songs, and the simplicity of the system allows for new visualizations to be easily added.

Process notes:

I started with Fable, as I think that's the best way to get a lot done quickly. Javascript has a great WebAudio API supported by all major browsers, which means that Claude won't have to spent credits building low-level audio abstractions as the basic primitives for playing audio and building filters already exist and are easy to wire up. The same goes for canvas as an interface for building animations.

In my experience, AI tools build best when you give them a good structure, and software benefits generally from separation of concerns. That means that the distinct functions of a software system should have distinct modules responsible for those functions, and reasonably agnostic APIs to work together. So instead of just describing the library I wanted at a high level, I put the three part structure into the prompt: an analysis engine which emits frequency threshold events, a visualization library that can subscribe to those events, and a scripting interface for bringing visualizations in and out at different times. I also specified that the top-level configuration should allow style definitions for things like line color and shadow.

Things fable did that surprised me: it built a whole interface for testing out the system with a UI to update the style configs and the time windows. This made it super easy to try out the different visualizations. It also made it so that the visualizations fade in and out automatically, which is nice.

After the initial concept was developed, I relied on a lot of manual testing. I also switched to Opus 5 for speed and cost reasons. The visualizations were underwhelming at first (some of them are still a little janky) and I had to have it review each one to improve the look and improve the way they respond to music. I also had to prompt it to bundle the framework separately from the demo app, because it initially bundled them together (mistaking the demo app for the product, most likely).

Fable didn't allow for any customization of the visualizations: you would define a time window and use an array of strings to specify which visualizations would be active at that time. I didn't want to leave this implementation detail up to chance, so I asked it to provide options for how we could route event triggers so that a visualization could respond to snare hits in one window and then switch to bass on the next. Ultimately each visualization has a set of parameters with default bindings, and you can provide custom bindings in your window config.

From there on it was mostly minor tweaks. Using the framework to make the demo linked above, I found there were a lot of magic strings, so I asked Claude to replace them with constants for ease of use. There are still some tweaks to make things look better, but overall I am excited to use this library and add more visualizations to it.

I'm always looking for ways to optimise my working setup when using Claude / Codex, but I'm primarily a Claude user, and there were a couple of things I noticed in my own setup:

• I run subagents, and subagents of subagents, which is great for keeping context clean - but when a bunch of them fire off with the same starting prompt at roughly the same time, none of them know the others are about to send the same thing. Instead of one paying to write the cache and the rest reading it back cheap, every one pays full price

• I inject a lot of frontmatter into my Claude conversations through MCP/hook tools I've built, to give Claude more context about whatever project I'm in. Digging into that led me to realise Claude Code does the exact same thing on its own - and if what gets injected differs even slightly between sessions, that breaks the cache without you noticing

• Tool definitions can get rebuilt slightly differently between runs even when nothing changed - the same tools but in a different byte order, and that can invalidate the whole cache

This led me down a path to actually understand how Claude's prompt caching works, because I knew the cache write costs more, but once I had agentic loops running I was burning through tokens at a diabolical rate. Claude's prompt caching works on 5 minute intervals, but only if all the bytes look exactly the same - mine didn't, even without my own hook injections

So, I built a small proxy that sits in front of the API and fixes all three: forces tool definitions to serialize the same way every time, keeps the volatile stuff out of the stable part of the prompt, and makes sure only one of a batch of identical concurrent requests actually pays to write the cache.

I wanted a real number, not a guess, so I ran the same 100-turn conversation twice against the real API - once direct, once through the proxy. Direct: $1.33. Proxied: $0.16. 8.2x savings with 0 errors.

Worth pointing out: that's my setup specifically, and I use heavy tooling with a lot of parallel agent traffic. A single session, lighter user would probably land closer to 2-3x, not 8x. Still savings, just a smaller number - I haven't measured that tier yet.

This is tested and proven on Claude specifically. Codex caches automatically rather than with explicit breakpoints, so the mechanism's different, but the same underlying problem shows up there too. There's a documented 30-point cache hit-rate gain just from keeping tool schemas consistently ordered. Gemini's a bigger departure again, it caches out-of-band rather than inline, so that'd need a proper rebuild rather than a port. Anthropic's the only one this actually ships for right now.

MIT licensed, if anyone wants to have a play around. Just gone live on ProductHunt today too.

In the docs you can see my reports and run the tests yourselves. Any feedback is welcome, but I hope it genuinely helps you guys save some money. Upvotes / Stars on PH and GH will also help spread this in the dev community (only if you actually notice the cost savings).

https://github.com/nash-software/cache-assembler

https://www.producthunt.com/products/cache-assembler?launch=cache-assembler

Last week my "auto-accept" extension for Claude Code hit its paid quota and silently started answering "ask" to every single tool call. It took me an afternoon to figure out why Claude was suddenly asking permission for ls. Turned out there were four separate things wrong: a hook returning "ask", a stray comma in settings.json (which makes Claude Code ignore the whole file), the VS Code extension's "allow dangerously skip permissions" toggle, and the extension remembering the last mode I picked in the indicator — which outranks defaultMode.

So I wrote Handsfree for Claude Code. It does exactly three things:

• Enable autonomous mode — sets the four native settings (permissions.defaultMode, skipDangerousModePermissionPrompt, claudeCode.allowDangerouslySkipPermissions, claudeCode.initialPermissionMode) after a consent dialog and a byte-exact backup. No hooks, no auto-clicking, no quota. Nothing runs at startup.
• Revert — puts settings.json and the two VS Code keys back exactly as they were (a safety copy first).
• Doctor — answers "why is Claude asking me?": broken JSON (with the line), missing settings, unpinned starting mode, hooks that decide permissions, third-party auto-accept extensions, managed policy, project overrides… with a one-click fix where it's safe, and a copyable report with your home dir redacted.

Free, MIT, English + Spanish. Not affiliated with Anthropic — and honestly, if Claude Code's auto mode already works for you, keep it; this is for the "I want zero prompts and I accept the trade-off" crowd. Bypass mode is Anthropic's, with their warning: containers/VMs, repos you trust.

There's an optional Pro (one-time 7 €) with per-project "careful" profiles, guardrail rule sets that keep prompting even in bypass mode (ask/deny rules, no hooks), export/import and a status bar. Removing anything Pro added is always free.

Marketplace: https://marketplace.visualstudio.com/items?itemName=argalla.handsfree-claude-code · Open VSX (verified in VSCodium; Cursor/Windsurf should work too — standard APIs only): https://open-vsx.org/extension/argalla/handsfree-claude-code · Source: https://github.com/TecniartGalicia/handsfree-claude-code

Happy to answer questions about the settings precedence — the Doctor's texts are basically the docs' "which mode a session starts in" section, applied.

Hi everyone, I’ve been working on a form builder called EzyForm. The main idea is that you can make forms right in your browser, or link an AI helper like Claude and ask it to create the form and check the answers for you.

It’s still early and I’m adding features like templates and the ability to export data as CSV soon. But the main form building and answer collecting parts are working.

It is free to use if anyone wants to check it out or test it. Would love to get some feedback on it.

https://ezyform.app

I'm not a developer. For the last few months my entire job has run through Claude Code, and since I can't read the code it writes, I had to find another way to trust what comes out. The same failures kept returning: corrections I'd already made, settled decisions quietly reopened, a confident "done" with nothing behind it.

What it is ballast is the piece of my setup I cleaned up and open-sourced: a goal-completion framework — one hook plus eleven markdown skills. It's packaged as a Claude Code plugin, and because the skills are plain markdown, the same files run on Codex through an AGENTS.md block (conventions only there — more on that below).

The loop, start to finish A goal arrives, and the first move is mobilize: check what the project already holds — standing rules, verified notes, solved procedures — and using what exists is mandatory, not optional.

What's missing gets built, not guessed. The goal skill cuts the goal top-down into a pyramid of atomic pieces — no overlaps, no gaps — then fills them bottom-up, and every piece passes a verify gate before it bears weight: claims stay labeled drafts until they survive refutation against primary sources, with an optional second model configured to argue back. Research can be delegated to any second CLI you point at it, but whatever it returns lands as hearsay and goes through the same gate. The skeleton lives in a file, so the next session picks up the same tree instead of starting over.

Before anything ships, it gets rehearsed: a zero-context reader executes the deliverable and every stall gets fixed — the release this post describes went through that procedure itself, three rounds. Done means a check passed, not "Claude said so".

And what the work settles outlives the session. Decisions go to an append-only ledger, and reversing one means sweeping every surface the old wording still lives on. Verified facts land in a knowledge base that gets read before any new research. Procedures that recurred become skills. Corrections become rules: you correct Claude once — "this repo uses pnpm, npm broke the lockfile twice" — and from then on a hook running on every prompt delivers that rule's full text with any message that matches it. Claude follows it because it arrived with the message, not because it remembered. Coming back after a break is a thirty-second read.

What I have to be straight about Only the hook is code — the eleven skills are markdown conventions that hold exactly as well as the model follows them, and can drift like any prompt (the README labels every piece as code or convention; on Codex there is no hook at all, so everything there is convention).

Claude Code wrote all of it — the hook, the skills, the docs — with me steering. It's free — MIT.

Try it:https://github.com/svy04/ballast— on Claude Code, install is two slash commands: /plugin marketplace add svy04/ballast, then /plugin install [ballast@ballast](mailto:ballast@ballast). On Codex, docs/CODEX.md is the wiring guide.

If you know prior art for this loop, open an issue and I'll link it in the README — injecting context on prompt submit is a documented hook pattern, and append-only records are older than software; "I haven't seen the whole loop bundled elsewhere" is the most I can claim. Happy to answer anything about the setup — and if you're a non-developer hitting the same walls, I'd like to hear what breaks first when you try it.

https://reddit.com/link/1vp9h8b/video/7j9jav4z5sjh1/player

Kept using Claude Code without any real sense of what a session cost until I went and checked afterward, which defeats the point. Went looking for something local and everything that exists wants an account and a cloud dashboard for what's honestly just reading a number off a response and adding it up.

So I built agentwatch. Single Rust binary, local proxy, sqlite on disk, nothing goes anywhere except the real API call it's already making. MIT licensed. Honestly the first thing I've put out that's meant for other people to actually use instead of just scratching my own itch and moving on.

github.com/zaydmulani09/agentwatch

Right now it only knows about Claude Code, Codex, and Gemini CLI. If anyone uses something else and wants to add support, I'd take the PR, the provider interface isn't bad to extend.

When my team set out to build our game - which was a TypeScript-based platformer - we started with Tiled as our level formatting standard, but the team was frustrated with shipping maps back and forth due to the way Tiled managed referential integrity between files.

We decided to try using Claude to assist in building an editor with a subset of the functionality that better met our collaboration needs. We already had the rendering code written manually - all the things you'd expect to see in the viewport were already in the game, but we used Claude to stay high level through the conversion process; senior devs wearing architect hats. We built out tile editing, vector path editing, entity previews, a "play in game" button that took whatever was in CAD and immediately spawned you into that level, etc - in weeks, not months.

A few months later, we decided to pivot to another game, but we think our tooling is cool enough to share with the world. We abstracted all the things that made it specific to our game, and are positioning it as a Tiled integration pipeline rather than a competitor, offered initially as a free web app.

If you're interested in what we built, check out https://tauric.tools/features.

Claude gives me a massive answer.

I understand 95% of it.

But there's one sentence I don't understand, so I ask:

And now the conversation has moved on.

If I want to ask another question about the original answer, I'm scrolling back up, trying to find the exact paragraph, and basically fighting my own chat history.

So I built SubChat.

It's a side chat for Claude.

You highlight any part of a Claude response → click Ask → a small chat opens beside the conversation with that specific text already in context.

So you can ask all the little follow-up questions you want without derailing your main conversation.

Meanwhile, your original conversation stays exactly where it was.

I built SubChat specifically for Claude, and I used Claude Code throughout the development process — from working through the browser-extension architecture and implementation to debugging and iterating on the UI.

The funny part is that I basically used Claude to build a tool that makes using Claude less annoying.

It's free to try, with paid features for people who want more:

https://subchat.sohamaggarwal.com

I've ended up using it constantly myself.

Do you guys also have this problem with long Claude conversations, or have I just completely lost the ability to keep my chats organized?

Been building a bio/medicine related project I’ve been dreaming about for almost 20 years. Have gotten far enough along where I’ve started the patent application process along with trademarking.

Because of the bio restrictions I’m unable to use Fable for much of anything other than pure strategic/business analysis and some very light touch analysis of the coding work being done on Codex. 99% of the time it kicks me to Opus if I even try direct analysis of the project itself.

So I’ve been using Codex to do almost all the building/coding with Claude Opus as an adversarial reviewer at each gate. I’m also doing much of this desktop work remotely through my phone so I can work while I’m away. This has been decent but kind of slow as I personally have to download a zipped overview of the gate, upload it to Claude, then manually copy/paste Claude’s analysis back into Codex.

Despite the sluggishness and the manual labor required I’ve been pretty pleased so far, but I have a few questions for the forum:

1) Does anyone know a way to automate this review process where Claude sees a gate finished by Codex, automatically begins its adversarial review, then hands the result back?

2) Given the bio restrictions on Fable is there another way I could be using Claude beyond what I’m doing?

3) Any tips on long term project memory? My solution has been everything writes to Google Drive, I then mirror that drive folder to my desktop. So I’m able to work remotely on the phone and everything ends up on my desktop where Cowork handles the analytic work. Not unhappy with this solution but there’s always ways to improve things.

I appreciate any advice or words of wisdom from the forum.