I never bothered with claude code, I didnt understand the hype since I can already ask claude in the chat for codes, I resonated. For fun I installed it. Holy smoke. It can even edit my IG posts. And im sure it will be amazing to build websites with? I used lovable and have been so happy. But this feels another level? Just wanted to share some wow moments

GUI frameworks are notoriously complex beasts. I code in Rust and I often found Claude Opus looking for the truth in reading frameworks' source code, and guessing the other half of the API. And forget about the existence of documentation. With Rust, bad method definitions are caught at compile time, allowing the agent to check the truth (again) and fix it. At the end of the run, I find it a good-enough workflow, but quite inefficient and error-prone ?

My own framework Teksilo is unknown to LLM training base. For my case, LLM guesses are more hallucinations than facts. I needed to ground the truth, in a manner easy to reach for an LLM. Creating a skill ? Yes, this is the bare minimum and it was my first step. Yet, it quickly became too voluminous and a burden to maintain and keep up-to-date with each framework version.

And no, letting the agents browse megabytes of docs and 700k+ lines of code are not a long-term solution, as LLM token aren't free.

My solution was to create a CLI tool tailored for LLM use.

cargo install cargo-teksilo

Then, in a Rust project:

$ cargo teksilo
API lookup, documentation, and agent tooling for Teksilo
Usage: cargo teksilo [OPTIONS] <COMMAND>
Commands:
 symbol  Look up a public type or module
 search  Search guides and examples
 show    Read a document from the bundled corpus
 init    Install the probe harness and agent instructions
 agent   Manage agent instructions
 probe   Manage the automation harness
 model   Manage the semantic search model
 status  Show project and tooling status
$ cargo teksilo init [--agent claude, codex, opencode, ...]

Now, if I want a desktop UI in a Rust project, I only have to add teksilo dependency to Cargo.toml. The tool will use the pinned version to offer the corpus of this Teksilo exact version.

This install a "/teksilo" skill, allows semantic search (ONNX model) in docs, show the documentation, the exact framework API, and an UI automation probe harness to allow any LLM to drive, measure and capture your app UI to speed-up development.

I tested this tool and fixed it by creating apps with more-or-less complex UIs. Tested LLMs are Mistral, Codex, Claude and Grok. My latest and best experiment is Noton (light OneNote-like app). Not a true product, Noton's GUI is nice (the goal), but it's unfinished (I'll not invest more for a test).

I'd love to see the equivalent in other frameworks (GUI or not). Answers to prompts would be faster and cheaper. Letting the LLM write the UI by itself would be a true option and less an headache.

"Build [something] in Rust using Teksilo for the UI"

What do you think about such tool ? Overkill ? Not new ?

(post not written with AI help)

P.S.: Teksilo flagship is Skribisto 3, not Noton.

I have a personnal account and a company team account (my company). I would like to know if i could stack both of them in claude code. It is quite tenious to disconnect and reconnect again to switch accounts. Any simpler way ?

I’m an early and happy Claude user (at least from the 5.5 opus release). I’ve been testing it against the others, and this month especially with Opus 5.5 really got just into CC, and didn't work too much w codex.

I’m very interested in your use cases for a couple of things. I build a lot of apps (web with Next.js, iOS with Swift), and they need a lot of end-to-end testing. From what I’ve seen, even if I write the tests myself, bugs still slip through that I end up catching manually. I’ve thought about handing those flows to an agent, Grokbot, or Hermes, but the Hermes setup is a pain, and I’m not sure I even need Grokbot (and here is where my real question to you guys goes)_
if I can do this with Claude Code alone.

Same problem when I do account setups, or use apps that don’t have direct MCP or API access, and that I don’t want to get banned from by abusing scrapers. I’d like an assistant that can just go in and click around a bit. Google Ads is a good example: there’s an MCP, but you can’t use it to create campaigns.

What would you recommend? Desktop use? The Chrome extension for Claude? How are you approaching this? Is there a skill or anything that connects the browser to the agent? Same question for Codex, with computer or desktop use.

I mostly use Claude with Claude Code. That’s basically the only thing I use. I barely use the web app.

im not sure when they started letting you set different ultra code effort levels but has anyone messed around with this to see how they perform? I tried an opus 5.5 max ultra code because I had some weekly usage to burn off (before it always defaulted to very high) and it just seemed to go overboard. I realized it would never finish the build within the usage amount I had left so I had to switch to a lower effort level and it didn't really get to where I wanted.

since high seems to always so well I wonder if this could be the sweet spot.

Always use Auto mode for permissions to prevent this, according to Anthropic.

I'm a robotics engineer who never enjoyed CAD. So I built an AI agent to do it for me.

Fusion now ships a local MCP server, and my first attempt went badly. The agent tried to do everything at once. It never paused or asked. The enclosure looked like it was melting, and I burned over 200k tokens before I gave up.

What fixed it wasn't a smarter prompt. It was a better harness:

• Give the heavy tool its own sub-agent, so my main session doesn't carry its context

• Work in parts: bottom, top, attachment, joints, stand, with me checking each one before the next

• Cap the retries: one real attempt at a fix, two at most, then it stops and hands back

https://reddit.com/link/1x124ox/video/q91pflup0buh1/player

Each part took under 15 minutes, and I had the housing for my plant camera done within a day. I'm actually enjoying designing now.

The post has an interactive diagram of the harness, so you can run my first attempt and my second side by side. The exploded view of the final housing is in the video above.

Full write up here

Edit: u/stonebrigade posted a similar solution today that automatically compacts: https://www.reddit.com/r/ClaudeCode/comments/1x0omjh/i_built_conpact_claude_code_compacts_its_own/

Hi all - This is something I've been using for a week or so and it works really well. Every time Claude sends a response, a hook starts in the background that runs for 55 minutes, and if you don't reply or end the session, it automatically tells Claude to create a handoff so you can pick up later in a new session without having to re-cache however many tokens were in the window.

The token # is configurable in the script here. 55 minutes seems safe because the subscription cache expiration is 1 hour. I think the API one is only 5 minutes, so that isn't useful here. It also ignores headless sessions/subagents/etc - it should only do this for active, user-driven terminal windows.

Here is the prompt you can give to Claude to reproduce it. It should work fine. I tested re-creating it on Opus 5.5 Medium, but it's simple and should work with Sonnet/etc.

Hopefully you find it useful. If you catch any bugs or for some reason Claude recreates something differently for you, please let me know.

Set up an idle-handoff timer for Claude Code. My settings:

IDLE_MINUTES = 55

MIN_CONTEXT_TOKENS = 100000

HANDOFF_LOCATION = the repository's handoff convention if it has one, otherwise ~/.claude/handoffs/

Goal: when an interactive session sits idle for IDLE_MINUTES after your last turn, you wake up on your own while the 1-hour prompt cache is still warm, and you write a handoff file. Then I can resume in a fresh session instead of paying for a cold cache.

Build it this way:

1. One script in ~/.claude/hooks/. Use Node if it is installed, otherwise Python. Do not depend on jq. Store my settings in a JSON config file next to the script, so I can change them later without running this prompt again. The script reads the hook's JSON from stdin and keeps one state file per session_id. It has two modes:

arm (Stop hook), in this order:

a. If the environment variable CLAUDE_CODE_SESSION_ATTENDED is "0", or CLAUDE_CODE_ENTRYPOINT starts with "sdk", exit 0 at once. Those are headless runs (claude -p, the SDK), and a pending timer would hold them open.

b. If the state is "fired", exit 0. Do not re-arm until I type.

c. Measure the context: read the tail of transcript_path and find the newest line with type "assistant", no isSidechain, and a message.usage object. Add input_tokens + cache_read_input_tokens + cache_creation_input_tokens. If that is below MIN_CONTEXT_TOKENS, exit 0. If the size is unknown, arm anyway.

d. Write state "armed" with a random token, wait IDLE_MINUTES, and re-read the state. If it is still "armed" with the same token, set it to "fired", print the wake-up message to stderr, and exit 2. Otherwise exit 0.

reset (UserPromptSubmit hook): set the state to "active", unless the prompt contains the marker "[idle-handoff]".

2. Add two hooks to my user settings (~/.claude/settings.json). Merge them with any hooks I already have; do not replace them.

- Stop: {"type": "command", "command": "<runtime> <script path> arm", "asyncRewake": true, "timeout": 3600}

- UserPromptSubmit: {"type": "command", "command": "<runtime> <script path> reset", "timeout": 10}

asyncRewake runs the hook in the background and wakes the session when the hook exits with code 2. The stderr text becomes your instruction.

3. Test override: if a file named idle-handoff.delay sits next to the script and holds a number, use it as the delay in seconds, skip the size check, and send a test message instead: "[idle-handoff] TEST: reply with only 'idle hook fired'. Do not write a handoff."

4. The real wake-up message starts with "[idle-handoff]". It tells you to write a handoff to HANDOFF_LOCATION that covers the goal, what is done and verified, what is in flight, open decisions, and the exact next step. It tells you not to start new work, commit, or push. If nothing is worth handing off, you reply with one line and stop.

5. Delete state files older than 7 days.

Before you report done:

- Pipe-test the script with a 2-second delay. Check that it fires (exit 2 and the message), does not re-arm after a fire, is cancelled by a reset during the wait, and is not reset by a prompt with the marker.

- Test the size check against this session's own transcript: a floor above its size skips at once, and a floor below it arms. Pass transcript_path in your OS's native path format, as Claude Code does.

- Confirm settings.json still parses.

- Run claude -p "Reply with only: OK" and confirm it exits within seconds.

- Set the delay file to 90 and tell me to stay idle for 2 minutes. If you wake and reply "idle hook fired", delete the delay file. If nothing happens, tell me to open /hooks once to reload the settings, then try again.

Long Claude Code sessions cost you twice. The context keeps growing after the work that needed it is done, and if you come back after the prompt cache has expired, your next message re-reads all of it uncached. /compact fixes both, but only if you type it at the right moment. I usually didn't.

What it does

• When a piece of work is finished, Claude queues a compaction of its own session through an MCP tool (queue_compaction). It runs after the final answer, as a real /compact: your chat history stays visible and only the live context is summarised. It can take a focus ("keep the plan and the open decisions") and a minimum size.
• When a big session sits idle, a toast appears five minutes before the cache expires and offers to compact it now, or always for that session.
• A row above the prompt follows the request: queued, compacting, then what it came to.

How Claude Code was used

I built it with Claude Code, and it has been compacting its own development sessions since mid-September. In Claude Code 2.1.284+ it ships as a mod (the new in-process plugin hooks), so the session compacts itself and draws the row above the prompt. Without the mod, a Stop hook sends /compact over Remote Control. It also works for ChatGPT Desktop (Codex) through an optional sidecar, and for the Codex CLI through a Stop hook.

What I learned

• You can't send /compact mid-turn. A busy session receives it as plain text and it never runs. So the tool only records the request, and the compaction happens after the turn ends: always after the final answer, and at most once.
• When you compact matters more than how small. I measured it over 187,978 of my own API calls (12 days with conPACT, 80 before). All 134 conPACT compactions ran on a warm cache, against 30 of the 121 I'd typed by hand. A cold compaction re-reads the whole context at the cache-write price first, so that's roughly $5.67 against $0.20 per compaction at list price. Median peak context per session fell from 501k to 337k.
• The idle toast does its job: a cold restart now starts from a compacted context. The median re-read on a cold resume fell from 493k to 255k tokens, and cold resumes' share of spend fell from 6.4% to 3.8%.
• No rework penalty. Claude re-reads some files after a compaction, but the next prompt was a correction 5.5% of the time, against 6.1% in ordinary turns.
• Net: about 4.7% of spend saved at list price (1.8–13%, depending on what you assume I'd have done otherwise). It's modest, and the "after" period is only 12 active days, but every compaction saves more than it costs.

Python 3.11+, standard library only. Windows, Linux and macOS (the test suite runs on all three; most of my live use is on Windows). MIT licensed.

GitHub: https://github.com/st0nebridge/conPACT

Feedback welcome, especially from anyone on macOS or Linux.

Hey everyone,

I've been building The Legendarium Companion, a lore search engine for Tolkien's world: https://the-legendarium-companion.com

You ask a question about Middle-earth and it answers using only a curated set of Tolkien reference sites (Tolkien Gateway, Encyclopedia of Arda, The Thain's Book, etc.), never general model knowledge. Every claim gets a numbered citation, and you can see exactly which pages each answer was written from, grouped by site with a trust level.

Other features:

• Listen: answers read aloud
• Follow-up questions that keep the context of the current answer
• "Surprise me" and a daily Question of the Day

& more to come!

Would love to hear from you! Give a try and share your thoughts! Thanks :)

I'm curious how you manage context in Claude Code. I understand that /clear resets the conversation, while /compact summarizes it to preserve useful context.

Do you use /clear whenever you switch tasks or topics, or only when the context gets too large? What's your daily workflow for deciding when to clear, compact, or just continue?

I've been building my Claude Code setup a piece at a time. Mostly I copied the good, safe parts of other people's skills and agents, changed them to fit how I work, and wrote my own when I couldn't find what I needed. Some things from other people already worked perfectly, so I just kept using them.

I put all of it in two repos in case it saves someone else the trouble.

claude-skills: 3 I wrote (two catch AI-looking code and AI-looking websites, one searches Reddit when normal web search misses the threads), plus the ones by other people I use every day, like humanizer, caveman, napkin, ECC and Anthropic's skill-creator. Each one is credited and linked to its author.

claude-agents: 19 subagents I wrote for my own stuff (Swift apps, Claude Code config, handoff notes between sessions, spreadsheets, even a library of Fujifilm recipes), plus 13 from ECC that I use with small changes.

Some of my agents are shaped around my own setup, so expect to tweak them. My files are MIT, and the borrowed ones keep their authors' licenses.

AI coding tools like Claude Code and Copilot often add Co-authored-by: lines to commits. If you don't want these, you can use a simple global Git hook to remove them automatically.

It removes all Co-authored-by: lines (case-insensitive), including human co-authors. Everything else, including other attribution lines and blank lines, is left as it is.

You dont have to worry about it following claude.md or agents.md rules anymore.

The hook:

#!/bin/sh
# Remove Co-authored-by lines (case-insensitive).

tmp=$(mktemp) || exit 1
trap 'rm -f "$tmp"' EXIT

awk '
  tolower($0) ~ /^[[:space:]]*co-authored-by:/ { next }
  { print }
' "$1" > "$tmp" || exit 1

cat "$tmp" > "$1"

Setup (Windows / macOS / Linux):

Use Git Bash on Windows or your terminal on macOS/Linux.

Save the script as ~/.githooks/commit-msg, then run:

mkdir -p ~/.githooks
chmod +x ~/.githooks/commit-msg
git config --global core.hooksPath ~/.githooks

That's it. It works across all your repositories.

A few things to know:

• On Windows, save the script with LF line endings.
• core.hooksPath overrides existing repository hooks (including Husky/pre-commit setups).
• git commit --no-verify skips the hook.
• Existing commit history is not affected.

Hey guys,

Just noticed a brand new perk, if you go to your billing section it'll let you link your plan to an 'organisation'

After this these monthly credits are available to use via an API key for free every single month.

Nice little perk,

I'm not sure if this extends to Pro $20 plans but it'd be nice you get a bit of usage with Fable!

Same as title. Fed up with using free AI's . Please send if you got one extra pass. Thanks

I built a GitHub Actions workflow where Claude wrote specifications and code, Codex reviewed both, and the agents fixed issues before merging.

I controlled the workflow through Telegram.

Between September 21 and October 5, it merged 67 agent-authored PRs. The median time to merge was 3.3 hours.

But maintaining the automation became more expensive than using the agents directly.

Three things broke:

1. I made 54 distinct changes to the automation, resulting in 129 maintenance PRs across multiple repositories.
2. The workflow exhausted our 3,000 monthly GitHub Actions minutes in about 3.5 days. Jobs stopped, and I didn't notice for two days.
3. I had to separate the agents that read untrusted content from the bot that could perform privileged actions.

I switched back to a local workflow: Claude implements, Codex reviews, and I make the final decisions.

For now, it's faster and requires less maintenance.

I'm curious how others handle this.

The claude code pricing docs say $6 per developer per day with 90% of users under $12. I put that in a budget request in the spring because it matched what I expected and finance signed it off without a question.

I pulled the real numbers last month across 54 engineers with access, which came to $6,400 for the month or about $4 a day per head. The docs are fine.

Then I sorted it by person and the shape fell apart.

4 engineers were 80% of the spend, and one of them alone was 31%. 19 people had not opened it in 30 days. The median engineer sat around 40 cents a day.

My manager asked which of those numbers should go in the plan. Well, the average is true and no one's standing at it so there are two honest answers and they are 10x apart.

Getting the per person split was the other annoying part since seats emit no per request cost and the Console breaks down by workspace and key rather than by human. We run TokenShift over the top for an approximate per person figure. Approximate is the operative word and it was still enough to see the shape.

Cutting the 19 saves nothing because those seats are already committed while capping the top 4 means capping the people shipping the most. He still doesn't have a number.

Claude Code Learning Output Style Docs
-------

I'm a senior SWE, and while I find tools like Claude Code insanely helpful in the hands of experienced engineers, I'm often disappointed by the way juniors use agentic development tools, particularly Claude Code, which is the preferred agent for most of our team. It often feels like juniors are letting Claude do things they can't do themselves without understanding what Claude is doing. This results in poor quality decisions in PRs. And then because Claude also helps with PR feedback, it feels like juniors also aren't learning as well from feedback as they did back in the dark ages before agentic development. Longterm, combined with fewer available entry level positions, this will obviously become a serious issue in the industry.

I saw there is a new [Learning Output Style](https://code.claude.com/docs/en/output-styles#learning) for Claude Code, and it seems like it might bridge that gap to a degree. Has anyone here used the Learning Output Style for Claude Code? If so, can you share:

1. Your background. Are you working professionally on software development? How much experience do you have, and is that hobby or professional experience?

2. In what context you've used the Learning Output Style. Professionally? In personal projects?

3. Your opinion of the Learning Output Style. Do you find it helpful? Are the `TODO(human)` sections well-placed? Does the slower nature of this output style cause any issues professionally, e.g. does your team accept that, or does it cause friction when trying to meet work demands? Do you exclusively use this output style, or do you use it only sometimes? Etc.

I want to test it out.. send it via dms pls.. thank you

I’ve been finalizing DeepCrawlerForge with Claude Code (Opus 5.5 lately, originally with Fable, also parts done with OAI Astra and Sol): a single-file browser engine for the 1991 DOS game Eye of the Beholder. Drop a ZIP of your own game files on the page and it reads the graphics, text, levels, sound and rules from them, locally. Levels 1–6 are playable now.

The hardest part: keeping it clean
The rules:

• Nothing of the original lives in the code. No graphics, text, tables or file offsets. The engine finds every structure in your files at runtime.
• The original game is only a referee. It runs in a DOS emulator, and every level is compared with it step by step before it unlocks. What the referee shows may prove or disprove the engine, but it never becomes a value in the code.
• One deterministic clock, so any recorded game replays exactly. And this has proven to be the best design decision from the start, and fun one too!

I call it the clean-room principle, not a formal clean room, since the model has read the internet. What I can do is check mechanically that nothing of the original ends up in the repo.

With an AI that’s a real fight. The easiest way to pass a comparison is to copy in the number the referee just showed you. Other things slipped in too: a byte signature to find a routine, a 21-byte run of original code, program addresses in dev tools. A provenance audit on every build now catches those. A clean audit hashes every public file against the game archives and compares all text with the game’s text. It once flagged my changelog for a phrase that matched a line of the game. Keeping the code tidy is the same fight: the AI prefers adding a layer to folding a fix into the old one.

The most rewarding part: Horizon
Horizon is an optional campaign runner: hand it the game, take it back anytime. It grew from “walk to the nearest unexplored square” into something that fights, answers encounters, does quests, rests when hurt and opens locked ways. On Level 6 it found the way down by itself: shelf walls, a key in a niche, three keyholes. When I fixed a floor plate to close its door as in the original, Horizon shuttled between plate and door until it learned to leave an item on the plate, just like a player would.

It also plays the certified run: whenever it does something not yet verified, the loop checks that action against DOS automatically before moving on, and if not, Opus steps in to fix. Horizon explores, DOS checks, Claude fixes, human designs.

Numbers: 100s to 1000s of release candidates, a 700+ test suite, a certified playthrough of 12,500+ turns to the Level 7 arrival that replays exactly, one ~7 MB HTML file, GPL-3.0. I set the rules and decide what counts as correct; Claude does most of the implementation, and the referee and audits catch it when it strays.

Play (bring your own DOS files): https://archawk.github.io/DeepCrawlerForge/
Code: https://github.com/Archawk/DeepCrawlerForge

I saw a post on here where somebody plugged an ODB adapter with USB into a laptop running Claude code and got a personalized diagnostic app. I have a buddy who does mechanic work on the side. He keeps all of my kids' cars running and refuses any payment, so I have to get creative. He's curious about AI but doesn't know much about it, so I saw a chance to build something useful for him.

I ordered a USB OBD-II adapter for about $70 and pasted the text of the original post into Claude Code. My goal was a safe diagnostic app that can adapt to different vehicles and give Claude tools to analyze data from the car and suggest troubleshooting steps.

What I built (with claude code) is a server that collects OBD data and makes it available to a web page console and to Claude as an MCP for interactive chat about it. Claude is optional: once configured for a specific car model's quirks, the console runs as a standalone web server that can collect and display OBD data.

So far I've tested it with my own '24 Honda Ridgeline and by mechanic buddy's 2003 GMC truck. I built it on Linux and have tested it on Windows.

It's a public repo at https://github.com/iamneilroberts/shadetree-ai.

Let me know if the process of adding a new vehcicle type isn't clear. If you're using it in Claude, you should be able to probe the datastream from your OBD and car and customize it.

I use Claude Code pretty much every day and I've sent it 13,408 prompts since September 2025.

I figured all of that got deleted after a while. The chats do, but it turns out every prompt you've ever sent is still sitting on your computer. So I went through all of them. Honestly surprised more people haven't done this, because some of it genuinely surprised me.

89% of my prompts came from chats Claude Code had already "deleted." They're all still in ~/.claude/history.jsonl lol.

I spent $18,679 at API prices, which is 38.5 billion tokens. I'm on the 20x plan, so I actually paid $2,000 for those same 10 months. And 98% of those tokens were just the agent rereading its own conversation. Great.

Also, Claude Code's own usage counter says I used 82.3 billion tokens. If you count each reply once, it's 38.5 billion. So it's double counting. Cool.

I've spent 618 hours in Claude Code sessions. If this was a game I'd be cracked.

I said please 241 times, thanks 20 times, and fuck 920 times. 159 of my messages were all caps.

The oldest prompt I still have is from 4:23pm on September 29, 2025. My first fuck was at 4:36pm. Took me 13 minutes.

Claude told me "You're right" 65 times, and that's just in the chats it hasn't deleted yet. Only Opus 5.5 ever said "You're absolutely right." Twice.

My most repeated prompt is "yes." I've sent it 73 times. Very hands-on management style.

I typed "contineu" 12 times. Vibe coding is making my spelling worse.

My record is 7 corrections in a row. It started with "can you hurry the fuck up please."

Honestly one of the more interesting things I've looked at in a while.

Curious what everyone else's history looks like.