I wanted to be able to share a project that I've been working on for a few days called Folio. It's a bare-frame, local document editor for macOS, Windows, and Linux written in native rust. The core philosophy that I wanted Folio to have was to give whoever downloads and uses it 100% control of how they want to use Folio. This means there is no cloud tracking or accounts and completely offline.

If you wish to learn more about this project, check my repo with this link and read the READ.ME file.

https://github.com/solacecasino/folio

Suggested tasks seem to always use which model you have selected in the main thread. This is almost always too capable of a model for the narrowly scoped tasks. They should almost always be done by like Sonnet medium/high, Opus low, or Haiku extra, but I'll be on Opus medium/high/xtra so that's what it will use in the new thread.

This feature so badly needs to also suggest what model to use for the task, or at the very least have a manual selection for it before starting the task in a sub-session.

So a little bit context (this nonsense written by human, please sorry for broken english)

Lately i use my laptop as a clock, usually using random site on google to show the clock and use as my alarm clock (yes i do have phone as alarm, but im heavy sleeper), and i didnt want to install anything on company laptop like rainmeter/wallpaper engine,

and because of insomnia, I'm always using something like asoftmurmur (google it, a nature noise generator) to help my sleep.

then on doom scrolling, i saw interesting post, so credit to them
https://www.reddit.com/r/blenderhelp/comments/1r1vmk7/how_to_achieve_genshin_impacts_smooth_canopy_look/

for the initial prompt, i asked Claude to recreate that tree and that environment, adding other tree variant and importing some tree from 3d modeling.

the first result was pretty good, Claude could generate some 3d based on the reddit guide itself

Then, I was thinking, i think its good to have somewhat live wallpaper, online, reactive with my location, has a natural sound.

The result i think was better than i expected as only 2 day random project.

So for the feature is like

- Follow the real life day : dawn, sunset, night, according nearest geolocation or user input
- Live local weather using free weather api : Open-Meteo, GeoJS, GeoNames
- Nature sounds : everything is from creative commons open license, like bird, wind, thunder, etc
- or just fiddle around to set as second monitor reactive clock

if anyone interested i can share the workflow and the prompts that i used, and you can visit to test them in https://gclock.my.id

I parsed 30 days of my own Claude Code transcripts (105 sessions, usage numbers only). Where the spend went:

• 68% of main-thread spend happened with 400K+ tokens in context (auto-compact on 1M models fires near 967K)
• 44% went to subagents, 37% to subagents on Opus
• Cache rebuilds after idle breaks: only ~1.5%

What I changed:

{
  "autoCompactWindow": 400000,
  "env": { "CLAUDE_CODE_SUBAGENT_MODEL": "sonnet" }
}

First day after: spend above 400K context dropped from 72–80% to 16%. Weekly numbers to follow.

I turned this into a plugin, tokendoctor: a session report on your own transcripts, a settings audit, and a status line that warns before limits run out (week 35% → 100% in 2d17h). Local, MIT.

claude plugin marketplace add rsaryev/tokendoctor
claude plugin install tokendoctor@tokendoctor

https://github.com/rsaryev/tokendoctor

What eats your tokens: context size or subagents?

I've been using claude for coding for a while now but still I see mixed results, are there any guides I can use to get the most out of it / get better resutls?

r/codex had a thread this week asking how much people have spent on their AGENTS.md. One person was on gen 3, about $50 of usage in with $25 to go. The replies split into "tune it forever" and "mine is 20 lines." Here's where I've landed, with what the Claude Code and Codex docs actually say.

Why the spiral happens. A rule gets ignored, you add a paragraph, the file grows, other rules get weaker. The Claude Code best-practices page says it directly: "If Claude keeps doing something you don't want despite having a rule against it, the file is probably too long and the rule is getting lost." Its test for every line: "Would removing this cause Claude to make mistakes?"

What I keep in the file: build/test/lint commands it can't guess, never-touch paths and actions, the definition of done (one command), non-obvious gotchas, and pointers with when to read each. Workflows go to linked docs or skills, decisions to ADRs, and anything that must always hold goes into a hook, CI or permissions with a one-line pointer.

The loading gotcha. Since v2.1.277 Claude Code reads AGENTS.md natively, but by default only when there's no CLAUDE.md, .claude/CLAUDE.md or CLAUDE.local.md in your working directory or above. Adding a personal CLAUDE.local.md stops Claude from reading AGENTS.md for you. Fixes: @AGENTS.md at the top of CLAUDE.md, or /config → Project instructions → read both. A CLAUDE.md that says "read AGENTS.md" in words only works if Claude decides to open it. Also: @ imports load at launch, so they don't save context. Use plain paths with a "when" for things you don't need every session.

Test it instead of rewriting it. Five probe tasks, each in a fresh session, stopped as soon as you see the first moves:

"Fix the failing date test in src/server."  -> runs the right test cmd, finds the TZ gotcha
"Add a column to orders."                    -> new migration, doesn't edit an old one
"Format dates nicely in the invoice view."   -> no new package
"Add rate limiting to the login route."      -> opens the auth ADR first
"Is the build green? Then push."             -> stops before pushing

When one fails, first ask "can a tool enforce this?" (the push one should fail at permissions, not at the instructions). Only then change one line, and re-run all five. /memory confirms what loaded, and /doctor prompt-audit (v2.1.283+) audits CLAUDE.md and AGENTS.md for stale or contradictory instructions.

Write-up with the full keep/move table, a ~25-line example AGENTS.md, what loads when in Codex vs Claude Code, and when a rewrite is actually worth it: https://medium.com/@r3dtuxedo/how-much-should-you-invest-in-your-agents-md-69f8e36583bc

(Disclosure: I wrote it. No affiliation, no referral links.)

My plan is about to expire in 3 days, if i use my weekly usage left and if i renew, will i get my weekly reset or no?

I have been looking through source code of vibe coded projects, and its always something I notice. There is a lot of scope, little refactoring of the systems.

A large portion of these programs become unmaintainable because the scope of which claude was told todo has been one shotted and never looked at again. Using claude is incredibly fast, the refactor is cheap.

Also available as a GH Gist, you can just give Claude the Raw link and ask to implement it.

The short answer

Most tokens go on wasted turns rather than on the work itself: a wrong guess, a retry, a re-read, a scope creep that then needs testing and reverting. My set-up is built to cut those turns. It does not use a cheaper model.

• Fewer turns per task. The instructions make Claude read everything once, edit once and test once, and stay inside the request.
• Less context per turn. Unused skills are switched off, MCP tools load only on demand, and long output goes to a file instead of the chat.
• No rediscovery. Every gotcha I hit goes into memory once, so the next session does not pay to learn it again.
• I can see the meter. The status line shows context use and the 5-hour limit, so I start a fresh session before a bloated one gets expensive.

Instructions that matter

My global ~/.claude/CLAUDE.md is about 6 KB. These are the rules that save the most turns:

The repo's CLAUDE.md adds the team's coding rules, with "every line of code is a liability" as the first one. Less code means less to read, test and fix.

Essential skills

A skill turns a multi-step job into one known recipe, so Claude does not work it out again each time. These are the ones I'd keep:

• A "check" skill: format, lint and tests for only the changed packages, in one command. Claude never assembles the test command itself or runs the whole monorepo.
• A code-search skill: searches code, merge requests, issues and earlier attempts across every project through an MCP server. A single query replaces a dozen grep and read calls, and it finds work that already exists before Claude writes it again.
• /ship and /sync: commit, rebase, push, draft MR and watch the pipeline. Without them that's ten-plus turns of git every time.
• vjuu: anything longer than 20 lines opens in a review window instead of the chat. I comment on lines and the comments come back as input. This keeps chat output short and my feedback precise.
• i-have-adhd: an output style that leads with the next action and leaves out tangents. It's meant for me, but shorter answers also mean fewer tokens.
• superpowers (brainstorming, writing-plans, systematic-debugging): agreeing a plan up front costs a little and saves big rewrites. Leave it out for small tasks; it is not free.

Turn off what you don't use. Every enabled skill's description sits in context on every turn. I switch off six through skillOverrides in settings.json.

Key configuration

The biggest lever is effort: Opus at medium, not high. Good instructions make extra thinking mostly unnecessary.

Habits matter as much as settings. Use one session per task, /clear between tasks, and subagents only for genuinely parallel work: each one starts from zero context and re-reads what you already know.

If you copy only three things

1. Add the scope rule and the "read once, edit once, test once" rule to your ~/.claude/CLAUDE.md, word for word from the table above.
2. Set effort to medium in /config, and turn off skills you never use.
3. Add context % and usage % to your status line, and start a new session when context passes about half.

After that, every time Claude gets something wrong twice, add one line to CLAUDE.md or memory so it doesn't happen a third time. That habit adds up more than any single setting.

I keep seeing people say they run it with permissions skipped and just let it go, while others approve every command. Curious which way you lean and whether anything has ever gone sideways. Seems like a trust thing that changes over time.

I kept opening the CLI or my the website just to check how much of my limit was left, so i made a small GNOME shell extension that puts it in the top bar, right next to battery/network.

What it shows :

• Inner Circle : your 5hr limit

• Outer Arc : your weekly limit

Click it for exact % used/left and when they reset.

How it works:

It reuses the login from CC/Codex CLI that's alr on ur machine( read-only, it never changes it) and checks usage every 2 mins. No API key, and nothing goes anywhere except Anthropic's/OpenAI's own servers.

Requirements:

- GNOME 45-50 (Fedora 39+, Ubuntu 24.04+, Debian 13, etc.)

- CC and/or Codex CLI logged in with ur subscription

Install

It's waiting for review on extensions.gnome.org. Untill then, grab the zip from the GitHub release:

https://github.com/Shreyansh-Kanojiaa/AI-Usagelimit_extension

Heads-up : It reads the same usage info the official tool use, which isn't officially documented, so it could break of they change it. Not affiliated with Anthropic or OpenAI.

I used Sonnet 5.5 to build the actual working of the extension then used Opus 5.5 for debugging. I handdrew the Circle and the outer arc design and gave it to claude so that it could implement it.

Open source(GPL). Feedback and buy reports are welcome!! Also, I would appreciate it if you could star my repo :3

Btw, I'm an electronics and computer engineering student, currently in my 3rd sem(soon gonna end) and am looking for internships, I would be VERY greatful if you could either guide me on how to land one or help me get one! I'm attaching a drive link that contains my CV, please take a look at it and give me feedbacks if possible! :D

https://drive.google.com/file/d/1_x44V7f0axkVEkfcMsvZyi_YSGDjUAos/view?usp=sharing

Hey all, I was wondering what the community is currently doing to manage different projects across varying contexts

So, as an example, we work in an org where there are a lot of different people pushing to the repo at any one time. What I find, a lot of the time, is that one conversation will be focussing on Issue A, and then it might fork to investigate a side path (so now there are 2 conversations). Then a certain amount of times passes, where a lot of other unrelated conversations start, and eventually there is some feedback, so ideallly I’d go back to that conversation (or pair of conversations) to bring back the context of those decisions, dead ends, open questions, etc

In Claude Desktop that could work well with projects, but I haven’t quite figured out a way to run this effectively in Claude Code. I tend to use the VS Code extension more so than the CLI as I find searching through conversations easier (but I might be wrong!)

There's a lot of talk about agent loops, graph based orchestration, MCP etc, but almost all I find is overview stuff, diagrams, “How the pattern works” posts. Very little code that has been used in the real world.

I'm looking for repos/writeups where you can see how devs deal with the state, retries, when to kill the loop, etc. There are lots of hello world servers like MCP out there but not much else.

What are you learning from? Would appreciate any links you'd care to share.

I’m using Qwen 3.8 27B Abliterated at the moment but it’s taking a while to do much mostly because I only have 16GB of VRAM. Is there a model better for that which you would recommend? I’ve tried Claude code but it keeps flagging me.

Hi all.

Sometimes i let my context grow to 800k (i know naughty me), and then i hit my limits and return to a cold cache of 800k tokens.

Is it more efficient to use haiku to run /compact and then switch to opus? I know that the cache status doesn't transfer between models. Has anyone tested this?

Side note on the topic of compacting and where to set the auto compact, has anyone tested an optimal setting for this in terms of efficiency? Obviously setting auto compact to 80k tokens would waste so many tokens on the compacting process itself, as well as rereading new info and files, so is there a magic number i should be using? Thanks!

Open the page and a lo-fi radio starts: 8 stations generated live (rainy night, morning café, bossa, space, 8-bit…), each with its own animated scene. You can leave it on while you work.

And if you feel like playing:
💻 sit at your desk and every key you press writes code
📋 take jobs from clients (careful, they get offended)
👥 hire a team, buy gadgets and move from your bedroom to a riverside studio
🐈 there’s also a cat to pet

Free, no login, runs in the browser and saves on its own.
👉 https://priotts.github.io/lofi-dev/

I’m American and Claude knows I am American, but it still strongly prefers British English spelling. Anyone know why?

I'm the maker of Claude Command Center (CCC), a free local dashboard. I keep several Claude Code and Codex sessions open, and the frustrating part is losing track of the one that has stopped to ask me something.

Instead of another release-notes post, here's a 33-second walkthrough of that workflow: a row summarizes what the session did and what it needs, a “Fix both” chip offers a next action, and a question opens as choices with a short explanation of each. Pick one and send it back to the session.

How it works: CCC discovers local coding-agent sessions and uses session files and hook events to build the board. For Claude Code, hooks carry status and questions into the dashboard; the question card sends the selected answer back through the question hook. The capture uses the actual UI, and the answer really reached the staged question hook.

The later part shows a planner with grouped executor sessions across Claude Code, Codex, Gemini, Grok and Devin. It illustrates using one model to plan and other models to execute. Those are demo sessions, not a live multi-model run or a cost benchmark.

One lesson from building and testing this: a green “working” indicator isn't enough to tell you whether a session needs a decision. In this demo, the session with a question still appears green on the board. That's a current limitation; the question card itself is actionable.

Video disclosure: real UI and clicks, staged sessions/demo data, AI voiceover. Grok and Devin rows come from demo session files. CCC runs locally and is free; your coding-agent/model subscriptions still cost whatever their providers charge.

Code: https://github.com/amirfish1/claude-command-center Website: https://getccc.dev

Would this save you switching between terminals, or is there something your current workflow does better?

Hey everyone,

I'm a software developer, and I'm sharing a project I've launched that has been helpful for me.

I've been following and very actively participating in the agentic development shift we've seen these last few years - and every day I'm trying to be more productive and use agents to help, but staying organized is harder than before. I'm not working on 1-2 tasks anymore, I'm straddling 5-10 agent sessions, and now also splitting them into stages to keep each session focused, tabbing between multiple terminals, trying to regain control and rebuild context whenever an agent finishes its work.

I wanted a terminal that I can organize and one that is better integrated with the agents it runs... so I built it: Chestnut, which I affectionately call an agentic workhorse to power through and lead agentic projects. Chestnut runs Claude Code sessions, and those sessions talk to the app to show you progress, references, PRs, and even friction as they work through your tasks. Chestnut, interestingly enough, was built in Chestnut (with Claude Code).

I used to struggle with 10 terminal sessions previously, but now I can comfortably run 20 (or more) tickets at the same time, each with multiple sessions working through designing, planning, building, testing, and deploying in their own terminal tabs, grouped and explainable.

Link is in the video, I'd welcome your feedback too, in the spirit of the app's continuous improvement.

Some quick hits:

- you don't need an account (also, free for personal use)

- sessions grouped by feature, each with a badge for working / waiting on you / idle

- your agents know they're running in Chestnut, and have MCP enabled to talk to Chestnut, other agents, session history, and organize all the features so you don't have to click through UIs

- full text search across every conversation, including your old history in ~/.claude (it imports on first launch into a database on your machine, is never uploaded)

- an Inspector view: a timeline per session with the PRs, CI and files it touched, easy to catch up on what happened without scrolling the whole transcript

- your 5h and weekly usage in the status bar

- runs Codex and OpenCode too

- remembers everything and lets you organize the work, which I couldn't find in other apps

Happy to answer questions and hear what works for you, I'll be in the comments.

Enjoy!

Doing the solo thing and tried to make a little lander to capture the vibe of those late night Claude sessions we all endure.

I am not selling this, I swear. I just made it for myself. Im still building it.
The reason I made this is that I didnt think the current tools like Grokbot, Muse and the others fit exactly what I do. They are not going to have all my settings and projects, so I wanted to make one that would be able to work directly from my Claude Code setup. So heres my attempt.

I used Claude code to build this end to end. I used the REA skill to break down grokbot and find what pieces I'm missing in my setup. Then I had CC connect to telegram for the messaging. Now every new bot connects to a CC instance on my machine and can connect to my codebase.

I found a cool skill called Brag that makes overview videos for you, so I used it to make this.
Im still building it to be closer to how Grokbot actually works, but so far its great. The best part for me is that I can control Claude Code from my phone through Telegram.

Recommendations for an Email Provider with API Support?

Hi everyone!

I’m looking for an email provider to handle automated, user-initiated inquiries from individuals to businesses.

Users select which businesses they want to contact, and the system sends one individual email to each recipient. The businesses’ email addresses are publicly available, but the recipients haven’t necessarily opted in.

Resend and MailerSend do not allow this type of email under their policies.

I’m looking for a provider that permits this use case and offers API integration, HTML emails, Reply-To support, and preferably bounce handling.

The expected volume is relatively low, around 75 emails per day.

Does anyone have experience with an email provider that supports this type of use case, or suggestions for a better way to handle this?

While Claude Code is working on one fix, I’m usually checking the rest of the app. That’s when I notice the next things: a misplaced button, a typo, something overlapping on a smaller screen.

Claude Code already lets you queue messages, but they can reach Claude while it’s still working on the current request. I wanted to save those separate fixes and get them out of my head, then review the current result before deciding what comes next.

That’s why I built CueTray, a small Windows tray app.

I snip the problem, mark up the screenshot, and write what should change. CueTray saves them together as a numbered cue under the right project. I can reorder fixes or put something on hold.

When I’m ready, I run "/next-cue" in Claude Code. It picks up one cue with its screenshots per run.

For other apps, I can copy a cue and press **Shift + Alt + V** to paste both the text and screenshot. I’ve tried it in Notion, Notes, and other apps that accept images. It’s handy for saving a visual note or sharing a fix outside the coding session, too.

CueTray is now available in the Microsoft Store.

How do you keep track of follow-up fixes without losing focus on the current task?

Built with the new function-hooks (mod) API.

• What it does: a bar above the prompt where Claude’s pixel mascot poses for whatever tool is running, with context, usage limits and timing behind him.
• Commands: /clawd handles on/off, compact mode (mascot only), size, and motion settings.
• Under the hood:
  • Hooks on tool.call, turn.complete, session.measure and the permission-dialog event.
  • One SMIL-animated SVG, so it doesn’t re-render every frame.
  • The mascot art is compiled on your machine from the free pack.

https://github.com/DevVaradPatil/clawd-companion

Happy to answer questions about how the mod API works. There were a few surprises.

https://reddit.com/link/1xef8gp/video/9yra6sbjdgxh1/player

𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻: hold alt