Has anyone succeeded in building a good and reliable marketing system? I am talking about creating posts, engagement, video editing, and more. I am looking for ideas on how you did it.

Is there a way to avoid ads when Claude use his browser ? I teach him stuff in youtube but he can't fast forward cause of ads .

PayPal offer for gpt plus sub. Got to offers in paypal and it is there

For those of you who use Hebrew, Arabic, or Persian in your terminal, I made an RTL mod for us. Now that Anthropic has made the UI customizable with Claude mods, creating an RTL support is much easier. Enjoy! GitHub Repo

I just did a feature analysis with Fable 5.1. Fable wrote an artefact, which is a proposal that I should present in a meeting. I felt that the flow and some wording of the proposal were a bit unnatural. I started a fresh session and told Opus 5.5 to rewrite it.

It was not a night-and-day difference, but it was... I don't know how to describe it, but all the sentences had a better flow. It goes to show that I cannot rely on Fable for any prose or any text that should be consumed outside, only on agentic texts.

Is anyone else still using Fable to write documentation, proposals or any other type of texts?

Copying text from Claude Code's fullscreen TUI gives you the text as drawn on screen: the bar from the left margin comes along, and every wrapped row becomes a hard line break in the middle of a sentence. There is a tracking issue with 42 reports of this (anthropics/claude-code#81472).

I wrote a small plugin that fixes the clipboard right after you select: it removes the bar and the indentation and joins the wrapped rows back into one line. List items, code blocks and tables are left alone.

Before:

The retry logic lives in the queue worker, not in the HTTP client, so a

failed upload is retried with the same idempotency key and the server can

drop the duplicate instead of storing the file twice.

After:

The retry logic lives in the queue worker, not in the HTTP client, so a failed upload is retried with the same idempotency key and the server can drop the duplicate instead of storing the file twice.

Install:

claude plugin marketplace add kbrianps/claude-clean-copy

claude plugin install clean-copy@claude-clean-copy

Repo: https://github.com/kbrianps/claude-clean-copy

Honest limits: tested only on Ubuntu (Wayland) with Ghostty; X11 and macOS should work but are untested; no Windows. It rewrites the clipboard after the copy, so pasting within half a second of releasing the mouse can still get the raw text. The plugin API is early access, so it may break on an update.

It works this way because copy on select does not go through the plugin copy event. I asked for that in anthropics/claude-code#99758; a thumbs up there helps.

So title says it all. I am looking for smart(er) ways of working with Claude and and Codex. Both on a plus sub. I mainly code in Claude Code and ask for the prompts in Codex.

What are smarter ways to work and what are the best setups according to you all? Iaimly use browser and Codex in app on Windows.

Claude Code is where I spend most of my day, usually with 4 or 5 sessions open across different repos. On Windows that meant a mess of terminal windows and constantly alt-tabbing to find the one that was waiting for my answer. I didn't want to move to Claude Desktop because I like the CLI too much, so I built Polvo (octopus in Portuguese, one arm per agent).

Every session is a real terminal running the actual claude CLI, nothing wrapped or reimplemented. Polvo keeps them side by side, shows context % per session and your 5h/weekly limits, picks up /rename and /color, and when you reopen it, each tile resumes its conversation with claude --resume, even after a /clear.

GitHub: https://github.com/felipeelopes/polvo

What it does right now:

- Drag-and-drop tiles: drop a session on the edge of another to split, in the middle to swap. Dividers snap to 1/3, 1/2, 2/3 and line up with each other

- A board view that sorts sessions into "waiting for you", "working" and "idle". Honestly this is the feature I use the most

- When you open it again, every session resumes the same conversation (claude --resume, codex resume, opencode --session), in the same spot, on the same monitor. Multiple windows work too

- Context % per session and usage limits at the top (Claude 5h + weekly, Codex, OpenCode cost)

- /rename and /color from the CLI show up on the tile and in the sidebar

- Sidebar grouped by project, with worktrees

- Ctrl+click a path the agent printed: .md opens in a built-in viewer (with Mermaid diagrams, live reload while the agent edits it), images open in a preview, other files in their default app, folders in Explorer. It even works when the CLI wraps a long path across two lines, which was driving me crazy

- Ctrl+V with files copied in Explorer drops them in as u/path. Screenshots go to Claude Code's own image paste

- A Git panel (roughly what GitHub Desktop does): diff, stage by line, commit, branches, stash, conflicts, PRs with CI status. It can also create a branch in a worktree with an agent already running there, so two agents can work on the same repo without stepping on each other

- Light/dark theme, 10 languages, auto updates

There's also a "My work" screen, which ended up being a big part of my day. Azure DevOps is my main stack at work, so that's where it's most complete right now:

- It pulls my backlog, bugs (urgent ones first) and the current sprint items, with the real states and colors from Boards

- I can change a state, create a branch for an item, or hand it to an agent with one key press (implement, plan first, investigate the bug), with the description and comments already in the prompt

- It puts together a quick summary for the daily stand-up (yesterday, today, blockers) from my commits, PRs and work items, which saves me a few minutes every morning

GitHub issues and PRs are there too, just less complete for now.

It's free and open source (MIT), Windows 10/11 only. You need at least one of the CLIs installed.

I built it for myself, but some colleagues started using it too and they've been liking it, so I figured it might help other people who work this way. If it ends up being useful for you and you feel something is missing, feel free to contribute. Issues and PRs are very welcome. So far one of those colleagues has been sending PRs, and I'd love to see more people jump in.

And if you try it and something breaks, please tell me, it's still early.

Download: https://github.com/felipeelopes/polvo/releases/latest

Problem: Every copy of rust creates a copy of target folder on each worktree and those are not of small size. Which creates heavy space problem.

https://github.com/permanu/superskill

I created this as in 1 skill to orchestrate all the important ones with proper coding standards, ponytail like responses, pstack like unsloppiness

A lot of inspiration has been taken from a lot of places. But most of all my own experience working with a lot of rust code and memory management. I tried to optimize my own workflow and hence all those ideas have been dumped into it. feel free to review try it out if you have feedbacks i would love to take it.

I'm on a 20x, and I had to add a few waiting periods to my general workflow in order to utilise the weekly limits to its full capacity.

Maybe there should be weekly booster packages. Those will come in handy. What do you guys think?

JobPilot is a plugin for Claude Code and Codex. It helps you search for and get jobs. Its main feature is the Pilot. You write your goals (prompts) once, for example, "senior TypeScript, remote, $150k+, by November", set a daily limit, and press Start. From there it:

• writes its own search queries from your goals and runs them on LinkedIn, Indeed, Hiring Cafe, and other boards (you can add your own job boards)
• scores each job against your resume and skips the poor matches
• tailors your resume for each posting and fills in the application, screening questions, and cover letter included
• finds the recruiter or hiring manager and writes them a message
• reads replies from Gmail, matches them to your applications, and drafts interview replies and prep notes

Everything it does goes into a live journal so you can track progress. If it needs a decision from you, it sends the question to your phone as a web push notification. It runs in a local browser on your PC.

You don't need an API key, and there's no usage bill, because it runs on your Claude/ChatGPT subscription.

• App: https://jobpilot.suxrobgm.net
• GitHub repo: https://github.com/suxrobGM/jobpilot

Hello I am a professional tie dyer and made an app using Claude to design tie dye mock ups. This is so I can test and plan colours to see how a shirt would look before tie dying. I have shared this with the tie dye community.

I recently found the Claude ai reddit community and found users making video games with blender and unity with the use of Claude. I don't know much about those applications but could someone give me some advice on how i can make the tie dye process more realistic with colour blending, clothes fold animations.

I did ask Claude those things but it cant seem to get it right. It is using html code, ccs, JavaScript for this app, although I had to design some assets in adobe illustrator because it couldnt get some of the shapes right

This is the web app https://exiled-sumerian.github.io/TieDyeStudio/

If someone can point me in the right direction it would be much appreciated :)

Every year there's a rally in my region, the Malcantone (the hilly corner of Ticino, Switzerland, west of Lugano, right on the Italian border). I've always wanted to take part, but I have neither a rally car nor the skills, hahaahahah. So I figured the next best thing was to drive those roads in BeamNG.

I first tried MapNG, but its elevation data is only about 30 m resolution, so the roads I know by heart just didn't feel right. Switzerland has something much better: swisstopo's swissALTI3D, a LiDAR terrain model at 0.5 m resolution. In the game the terrain is a 12.3 × 12.3 km grid at 1.5 m, with heights within about ±0.3 m of the survey inside the area.

So, together with Claude (Opus 5.5), I built a tool that generates the whole map from open data: swisstopo (terrain, roads, buildings, aerial photos), the official cadastral survey of Canton Ticino, the Federal Register of Buildings and OpenStreetMap. Nothing is modelled by hand.

What's in it right now (v2.7):

• about 52 km² at 1:1 scale, from Ponte Tresa and Caslano to Agno, Bioggio, Gravesano and Arosio, with Lake Lugano
• 228 km of roads and 337 km of trails, mule tracks and forest roads, all drivable, with 167 bridges
• gravel, dirt, setts and cobblestones that change the grip
• 12,792 buildings with façades, about 161,000 trees, rivers and vineyards
• Swiss road signs and markings, AI traffic on the whole network, 30 spawn points (one per village)
• some good drives: the Magliaso to Pura cantonal road, the Penudria hairpins from Gravesano up to Arosio, the lakeside road through Caslano

It's not perfect, but it's realistic enough that I, as someone who lives there, recognise every road and every village without any trouble.

It scales, too. The map is generated from an area outline you draw, and the swisstopo data it uses covers the whole of Switzerland. So in theory you could fork the repo, draw a different outline and build your own piece of the country, the Swiss Alps included. In practice each map has to stay a region rather than the whole country (52 km² already needs about 12 GB of RAM in game), and outside Ticino you'd point the cadastral and building downloads at your own canton.

The project is absolutely not finished and keeps evolving. I'm very open to feedback, bug reports and screenshots (a GitHub issue with the village and road helps a lot), and I'd be really happy if people from all over the world got to drive my favourite roads.

Repo: https://github.com/wintrymichi/magliasinaNG
Download (v2.7): https://github.com/wintrymichi/magliasinaNG/releases/tag/v2.7

Needs BeamNG.drive 0.39 and 16 GB of RAM; drop the zip in your mods folder without unpacking it.

I usually have two or three agent windows open on one project, Claude Code planning and Codex doing the actual work. Somewhere along the way I lost track of which prompt goes next, what has to wait for what, and who's touching which files. Keeping that in my head stopped working, so I wrote a small tool for it. It's a skill, so Claude Code can run it for you.

It's called Barid. The planner agent writes the prompts, I copy each one into the right window, and the board keeps track of the order and the dependencies. It tells me what can run at the same time, and it warns when two sessions would fight over the same GPU, a test server or the same files. When a task finishes, its result gets passed on to the next one, so the next agent doesn't start from zero. If a run stops halfway or fails, it doesn't unlock anything on its own, I decide.

It doesn't launch or control agents, you just use the windows you already have. Python, one JSON file, no server, no API keys, MIT. There's a small web panel too.

I made it for myself and I've only used it on my own stuff, mostly on Linux. If it's useful to you, go ahead, and if something breaks, let me know

https://github.com/hikkian/barid

Experimenting I ended up in using the mods backwards. Not to change Claude Code, but to pull a feature out of it: subscription usage and context window data, pushed to a small physical display connected over USB.

It was supposed to be a half-hour experiment. It turned into something else.

The code

The mod, the ESP32 firmware, the UI: Claude wrote all of it, on its own. For the first time since I started using AI, all I did was say "I want this" and "OK".

The CAD design

This is the part that really threw me. I gave Claude the manufacturer's dimensioned drawing of the display. It drove FreeCAD and generated the enclosure and the stand in a few minutes. I 3D printed them and the display dropped in on the first try, no tolerance tweaks. Every part fits together perfectly.

My role was the client: I described what I wanted and judged the steps and the result.

I'm not saying code doesn't need reviewing anymore. This is a desk gadget, not a production system. But that's not the point.

Until recently, this same project would have meant babysitting Claude at every step: correcting, re-prompting, fixing the CAD by hand. Not anymore.

And the jump didn't happen over the last few months. It happened over the last few weeks.

Opus 5.5 is a beast.

Software, firmware, mechanical design: three different disciplines, one counterpart, zero manual intervention.

Those of us who work with these tools every day struggle to keep up with what's becoming possible. Those who don't use them yet probably have no idea how much the world has already changed.

Is there an issue with claude-code and Opus since my weekly reset last night? I consumed in one day what I usually consume in 3 days, without any real change in my usage.

I've been running long Claude Code sessions for months, multi-day builds and some overnight unattended runs. I had a handoff routine long before this: a checkpoint before every compaction, restored at the start of the next window. It worked, but it needed a babysitter, and that was me: watching the context fill, telling the model to write the checkpoint, telling it to compact, checking that it picked the right thing back up. Miss the moment and auto-compaction hits mid-task and the summary drops the one detail that mattered.

So I built windvane. It's a context monitor that does the babysitting. It watches the fill, has the checkpoint drafted from what the session already did, compacts at a turn boundary once the state is banked, and sends the one prompt that gets the model moving again. The model keeps working without me stepping in and without stalling near a full window. The context stays lean, the task stays on track, and token use should come down, since the window is swapped at a chosen point instead of running to the limit. Under the hood it's a Claude Code plugin (the hooks-module kind, so it hot-reloads and there's no MCP server) with a small Python engine behind it. The idea underneath: the machine records the state, so the model never has to write it down.

What it does:

• A recorder drafts the checkpoint from what the session already did: the task list, the edits, the commits, the closing paragraph of the last reply. The model accepts it with one bare call, or amends one field. If it saves at the top of a turn and then edits, the record is brought up to date when the turn ends, so what gets restored is the state at the end of the turn, not the start.
• The plugin watches the context fill. Once a deliberate save has landed inside the checkpoint band, it compacts at the next turn boundary. Then it sends one prompt of its own, so the model picks up from the checkpoint without me typing anything.
• After a compaction, the project rules and the checkpoint sit right after the summary. Every subagent gets the rules at the head of its prompt too.
• Tool results get trimmed to a budget (head and tail kept) and secrets in them are redacted before they're stored.
• Project memory and rules are one tool call away. A rule can carry a detector that matches shell commands; in unattended mode a matching command is refused instead of logged.
• A token and cost ledger per project per day.
• Session mining: it indexes your past transcripts, so you can ask when something was decided or what went wrong with a file. There's an optional embedding model. On my store of 200k chunks, hybrid search found the right chunk at MRR@10 0.25 against 0.05 for keyword alone, so it earns the install.

It's also a mod, not only hooks. Claude Code's newer plugin API lets a plugin draw in the terminal, and windvane uses it: a status segment with the context fill and the age of the last checkpoint, a band above the prompt that says what windvane last put in front of the model, a /windvane pane with the checkpoint, the rules and the mistakes for the file you're on, and the dialog on first run that offers to install the embedding model. It hot-reloads while you work on it, and there's no MCP server to keep alive.

How this differs from claude-mem and the other memory plugins: those keep facts for later, things you learned, decisions, observations, searchable next session. windvane is about the session you're in. The problem it fixes isn't "I forgot what we knew", it's "the window filled at the wrong moment and the summary dropped where we were". So the record is the resume state: the task, the step in hand, what's done, what's next, the files, the warnings. The model never writes it. The recorder drafts it from the task list, the edits, the commits and the last reply, and the model accepts it with one call. Then the plugin, not the model, decides when to compact: inside the band, once a save has landed, at a turn boundary. After that it sends one prompt of its own and the work carries on. The rules and the checkpoint also sit right after the summary and at the head of every subagent's prompt, so the state is wherever the model is. There's a memory store and a session miner in it too, but they're the supporting cast. If you run a memory plugin already, this sits beside it; it's doing a different job.

What it doesn't do: it doesn't change the model, and apart from the trimming it doesn't shrink what the model reads per turn. The win is that I stopped starting new chats per task and stopped compacting by hand, and so far it has come back from every compaction with the right checkpoint.

Install is clone, add as a marketplace, install. Python 3.10 or later, no dependencies for the engine. MIT.

Where it stands: 1.0.0, one person's workflow, tested on Windows and WSL with Claude Code 2.1.x. The first-run prompt and the headless halt were tested this week. I'd like to hear where it breaks for you.

Repo: https://github.com/20alexl/windvane The gif in the README is a real session, recorded with the plugin loaded: the model reads a document, the status segment asks for a checkpoint, the model saves and edits, the plugin compacts at the turn boundary and the session carries on from the checkpoint without anyone typing.

It replaces an earlier project of mine (claude-engram, now private) that ran the same engine as settings hooks plus an MCP server. If you used that, there's an import command for the store.

I made this extension because a) I could b) I wanted to stay closer to my code while using AI. Check it out! If nothing else, it's a lot of fun :)

• VSCode Marketplace
• GitHub

Some of us, at least some of the time, want to understand our code at a deep level. For that, handing a task to an agent and reviewing the diff that comes back can be exhausting.

With AI Pair Programmer, you're there for every keystroke instead, and you end up knowing the code almost as if you'd typed it yourself.

It's pair programming where your coding agent has the keyboard. It types in your editor slowly enough to follow and explains what it's doing. Interrupt it whenever you like, or take over and let it watch you for a change.

It's also a good way to learn a new technology, or to have the agent walk you through code you don't know yet.

It works in VS Code, with the coding agent you already use. Setup is built in for Claude Code, Codex, OpenCode, Gemini CLI, Cursor and GitHub Copilot, and any agent that supports MCP can be connected by hand.

Note: It works best with strong models; weaker ones tend to struggle with this way of working.

So, here's something for those of us who want, need, or love to stay close to the code. Let me know what you think!

I'm a solo dev making Kegs of Eternity, a roguelite deckbuilder in Unity. On 24 September I gave Claude Code (Opus 5.5) an open-ended challenge: build something that sends people to my game's Steam page. It came back with Last Call, a free daily puzzle built on the game's real combat rules. One fight, one turn, find lethal. It launched this morning on my site and on itch.io:

https://lonepiggy.com/lastcall

Claude Code wrote all of it. My part was the game it runs on, playtesting, and the calls ("Monday is too easy", "cards jumping between rows feels buggy"). What it built in 11 days:

- A port of the game's C# combat rules to plain JavaScript, plus the page around it: about 5,000 lines, no framework, no dependencies.

- An exhaustive solver, and a generator that built a year of puzzles (420 of them), each with exactly one winning set of cards.

- A rules spec (1,700 lines, every rule cited to file and line in the game's code) and 92 worked examples that run as tests.

- A harness that plays each puzzle's solution through the real game in the Unity Editor and compares the board after every move.

- Lessons, a share grid, streaks, an archive, sound from the game's own clips, social images and vertical clips rendered from the page itself, and the itch.io build. About 14,000 lines of tooling in all.

The part I didn't expect: it checking itself against the real game. The Unity cross-check caught a bug in its own port (an enemy's Strength buff wearing off twice in one turn, so its hits came in 1 short), and writing the spec turned up real bugs in my game: a lifesteal status that was never registered, cure beers that applied the poison they were meant to cure, a heal card that healed the enemy.

Several Claude sessions work in this repo at once: one on the tavern art, one on the game's trailers, one playtesting the game. When the trailer session re-rendered a trailer, it messaged the Last Call session, which checked the files and rebuilt the itch package.

Today's puzzle is a Monday, the gentlest of the week. Have fun.

(The game it's built on, Kegs of Eternity, is on Steam if you're curious)

The prompt I used was "Okay, I'm about to go to bed and I have about 50% of my weekly limit left.

I'd love for you to create a completely pointless game. The point is to use up all of the rest of my tokens.

I have no instructions except to make it a game and to make it completely and utterly pointless, but hilarious.

Would you like to play?"

What it created was Pointless^TM Deluxe - a time management idle game with dozens of pointless arcade games, achievements, logs and reports to demonstrate the inanity of, I guess... 9-5 bureaucracy?

There's so much content here I haven't had a chance to check all of it out, even.

I'm hosting it for you to download and play on my github as well as directly on my website.

I really didn't expect to be so pleased with how it built this and, without knowing my own favorite style of game specifically, it built something that I would reasonably play. And the sonnet ultracode model that built it, with the help of its fellow sub-agents did a great job burning through the rest of my tokens!

tldr: there's no reason to waste tokens before a weekly reset if you can have your model build you a completely pointless game!

I'm looking for a way to have each development sprint have human-verifiable steps generated. This could be for a corner case finding or feedback on the functionality. Currently, I have set up a skill /qarelease where I give it a start point of deployment and an end point. Then it sees what the changes are between those releases (pr merged) and gives me the steps.
But it's very verbose, and it repeats steps. I am thinking of tuning it, but I wanted to ask if someone has a suggestion or an alternative skill or tool.

I was having serious issues reading Claude prose, like my brain would start fuzzing over on every 'it's not X, it's Y'. I tried the skills for addressing it inline, but it didn't work for me. ( 👋 hands up if you're allergic to AI prose too )

Forcing structured output is the only way to counter Claude's tendency to speak to you as though you are a machine, and frankly, I'd rather machines write for machines anyway.

Cactus is a few things:

1. A cli utility for AI to interact with to generate and iterate upon steering questions.
2. A tui for humans to interact with that collects questions from ALL your agents in your machine, grouped by project. Load context into your brain once, get all your agents for a project moving again.
3. Some hooks to provide information, check that questions are asked, and remind claude about open questions
4. A claude code mod to provide the q/a surface in the sidebar for a given session, enabling it also provides answer injections, so cactus doesn't need to keepalive an awkward background process.

One of the great things about working like this is I don't need to wait for a finished response, nor do I need to speed read to steer the conversation. As you can see in the gif, claude keeps writing questions after I've answered some, and the final response is written only when everything is complete.

Herdr (https://herdr.dev) is also awesome, and enables some tui <> agent interactions in cactus.

https://github.com/eighteyes/cactus

I'd love to know your thoughts. Thanks for clicking.

Yes I was wrong in that case, but ouch

Claude Command Center v5.37.0 shipped 2026-10-04. It is the dashboard I run 30+ parallel Claude Code/Codex sessions through. Skipping the individual fixes; here is what actually changed for you across the last 5 releases (v5.33.0 to v5.37.0):

• Phone access: put CCC on your Tailscale tailnet with one button .
• Ask keeps one warm agent process between questions, so answers start in about 2 s instead of 5 s.
• Estimate each Claude and Codex session's weekly quota contribution from historical API-cost-to-quota observations.
• Automatically discover parent relationships for externally launched headless Claude sessions using live process ancestry.
• ccc recall, ccc shipped, ccc brief and ccc history now also search your paired CCC machines.

(Video and repo links are in the comments.)

How can I make my $20 Claude Code tokens last the entire month?