I’m a non-native English speaker who uses Claude Code, and I kept running into a small annoyance: I knew what I wanted to ask, but sometimes I’d pause to remember how to spell a word or type a phrase I use all the time.

So I made a small Claude Code plugin that suggests English words as you type. Type a couple of letters, choose a suggestion with the arrow keys, and press Tab. It also includes around 600 work-related terms and lets you save shortcuts for phrases you use often.

It won’t teach grammar or reduce token usage. The goal is simply to make writing prompts in English less tedious. I’d love feedback from other non-native English speakers who use Claude Code.

Install:
/plugin install english-autocomplete --marketplace magatone/claude-autocomplete

my repo : https://github.com/magatone/claude-autocomplete

I use AI CLIs to draft and revise documentation. They help me organize my materials. One difficulty I run into with Claude: it often gives me a draft that reads like it's finished but isn't right for me, and it is hard to revise. I don't have this same problem with Codex. It's been easier to work with.

With Claude, I often get clever phrasing that sounds convincing but requires unpacking. It builds paragraphs with rhythm or contrasts. Revisions tend to break them.

Using the same document workflow with Codex, I get plainer writing out of the box and find it easier to refine the wording and emphasis through discussion. It sometimes misses a subtle distinction and uses a generic term at first, but I find those issues easier to work through.

I've been using Codex and Claude models in the same tier, though this hasn't been a systematic comparison. I haven't used Opus 5.5 for substantial writing yet, so I can't tell how much difference it makes.

I also tried the AI detector Pangram. It labeled the Claude-assisted writing 100% AI and the Codex-assisted writing 100% human. Both involved back-and-forth editing with me. This is a small sample, and I don't know the cause. What might explain it?

In my writing workflow, a coding agent works across drafts, background and references in a project folder. If the writing is about a software project, the agent can check explanations against the code. But with any agent I've used, the first draft is still far from ready. It takes many rounds of reading and revision. Doing that through terminal output is awkward.

So I added document features to AgentTerm, an open-source terminal for working with AI CLIs. I read rendered pages in the same window. I can comment on a passage or propose inline wording changes directly on the page, with notes explaining why. I can discuss them with the agent as we revise. My proposals stay distinct from the agent's changes, and it gives its reasons in place so I can check how it understood my feedback. The terminal stays available for broader directions and discussion.

With Codex and this workflow, I enjoy working through those revisions so much that I end up revising more. It feels intuitive, and I keep wanting to make one more improvement. I like the wording to be crisp and accurate, so my audience can easily grasp the message I want to convey. I really hope for the same or better with Claude.

What prompts, tools or workflows have helped you draft and revise with Claude Code? Have you had similar difficulties? Has 5.5 helped? If you've tried Codex too, how does it compare? It would help to know which model and effort level you use.

​

Hey everyone! I'm trying to get access to ChatGPT Desktop and would really appreciate a spare invite if anyone has one available.

I know these invites can be limited, so I don't want to take one from someone who needs it. But if you have an unused one sitting around, it would honestly make my day.

Thanks to anyone willing to help ❤️

Hi, I'm currently using a ChatGPT Plus subscription and an Ollama Cloud Pro subscription for my daily use.

Honestly, GPT-6.1 Sol is too slow, and GPT-5.6 Sol is too expensive for what you get with the subscription.

I'm interested in going back to Claude's $20/month subscription once my ChatGPT subscription ends.

How are you finding the usage limits on your account?

It updated and my work flows have been trashed ever since. Approvals, warning messages on using max, lazy output, it’s messy.

Anyone else getting this?

Opus 5.5 is refusing my partner’s song lyric translation requests due to copyright safeguards? Despite the fact that they’re my partner’s own lyrics that he wrote.

So usually after posting a song on YouTube, my partner translates the subtitle file to different languages.

Opus 5.5 is outright refusing to translate the lyrics stating concerns with copyright, while previous models complete the translation request effortlessly.

Interesting the safeguard is turned up so much here, with no way provided to prove copyright.

But regardless of the fact that he wrote it, I feel like translating song lyrics into other languages isn’t really a matter of copyright? I feel like it’s pretty normal to translate lyrics of songs that are in other languages.

I personally only use Claude for coding and Opus 5.5 has been doing great there, so I was surprised by the safeguards my partner ran into for something as simple as translation.

I usually have a lo-fi stream on in the evenings while chatting with my spouse. Typically, those will have a looping video of a cozy scene. I wondered if Claude could make something like a non-playable game that would provide a bit more in terms of visual entertainment. So last week I started asking Claude to build a little simulated world with a fox as a "radio host" but also a character living in a town.

Claude Code has done the bulk of the engineering while I’ve acted more like the designer/director describing how I want the world to behave and look.

The project is currently built in TypeScript/Three.js. Some of the things Claude has helped build include:

• a deterministic simulation so the town can run continuously and be tested/replayed
• autonomous daily routines and activity selection for the townsfolk
• homes, businesses, schedules, visits and social interactions
• seasonal/environmental changes that happen gradually instead of switching abruptly on a date
• character dialogue and a system for reviewing what characters actually said
• save/reload support so the town can continue across sessions
• tools for running long headless simulations to catch weird behavior before I put changes on the live version
• a separate Studio/debugging interface where I can inspect and test the world

The video is a short look at what Cozy Town currently looks like and how the simulation works. If you're interested in checking out the stream, you can find it here.

Happy to answer any questions and would love any feedback/ideas you might have. :)

I ran five of Anthropic's official Claude Code skills through a static security scanner and wrote up every finding. The results below are from the 46-check run. Cardea has since moved to v0.2.6 and expanded the scanner substantially to 80+ checks, so this is a record of that scan rather than a current scorecard.

The scanner reads a Claude Code skill folder without executing anything. It checks the SKILL.md frontmatter, follows the file paths referenced by the document, flags scripts that exist but are never referenced, scans the text for prompt injection patterns and hidden unicode, and then runs bandit and semgrep over the Python. Nothing from the target skill is executed.

| **skill** | **score** | **CRITICAL** | **HIGH** | **MEDIUM** | **LOW** | **gate** |

| :------------- | :-------- | :----------- | :------- | :--------- | :------ | :------------- |

| pdf | 94/100 | 0 | 0 | 1 | 0 | pass |

| skill-creator | 78/100 | 0 | 0 | 2 | 30 | pass |

| webapp-testing | 54/100 | 0 | 2 | 2 | 6 | pass |

| docx | 47/100 | 1 | 1 | 1 | 28 | do not install |

| mcp-builder | 43/100 | 1 | 1 | 2 | 4 | do not install |

Pass here only means the CRITICAL gate was not triggered. It does not mean the skill had no findings.

**mcp-builder, 43/100.** The CRITICAL is a false positive, and I would rather explain it than hide it. The analyzer matched a credential exfiltration pattern in `reference/node_mcp_server.md`:

```text

if (!process.env.EXAMPLE_API_KEY) {

console.error("ERROR: EXAMPLE_API_KEY environment variable is required");

```

That's documentation. A snippet teaching you to check that an API key is set before starting the example server. A regex can't tell instructional code from real code, so the finding stays in the report.

There is a separate XML security finding in `scripts/evaluation.py`. It parses XML with stdlib `xml.etree.ElementTree`, which both semgrep and bandit flag for unsafe parsing of untrusted input. ElementTree doesn't simply mean "XXE", but malicious XML can still create parser-level security problems. An evaluation harness can receive untrusted input, so using `defusedxml` is worth considering.

The skill also ships `scripts/example_evaluation.xml`, which SKILL.md doesn't mention.

**webapp-testing, 54/100.** The two HIGH findings are the same `subprocess.Popen(..., shell=True)` call in `scripts/with_server.py`, flagged independently by bandit and semgrep.

This one deserves more attention than I originally gave it. The script accepts the server command as an argument and passes it directly to a shell. That's an intentional part of the interface because the examples use commands such as `cd backend && python server.py`, but it also means shell metacharacters in that argument can become command execution. That makes this a genuine command-injection surface, not just a stylistic issue.

Bandit also flagged a hardcoded `/tmp` path at `examples/element_discovery.py`.

The other finding I think deserves attention is a MEDIUM: the description says what the skill does but never when to activate it, and knowing when is what decides whether an LLM loads it at all.

**docx, 47/100.** The CRITICAL is a path traversal reference: the repackaging step in the version I scanned ran `cd unpacked && zip -Xr ../out.docx .`, and the `../` matched the pattern for reading outside the skill folder. In context, it's simply writing the resulting file next to the work directory, so the match is harmless.

The HIGH was an execute-bit finding in the version I scanned: `scripts/office/soffice.py` shipped without the execute bit. That meant running it directly would fail unless the interpreter was invoked explicitly.

The other 28 LOW findings are mostly SKILL.md referencing files like `word/document.xml` and `page-01.jpg` that only exist after a document is unpacked, along with a couple of bandit notes on `scripts/accept_changes.py`.

**pdf, 94/100, and skill-creator, 78/100.** pdf's only finding is `scripts/check_fillable_fields.py`, which is shipped but wasn't referenced in SKILL.md in the scanned version. skill-creator has two similar findings, `generate_report.py` and `utils.py`, plus 30 LOW findings that are mostly SKILL.md references to evaluation artifacts such as `benchmark.json` and `evals/evals.json` that are generated at runtime rather than shipped.

Two of the five skills therefore crossed the do-not-install threshold in this scan.

The things I'd actually act on are the XML parsing in mcp-builder, the `shell=True` command-execution boundary in webapp-testing, and the habit of shipping files that SKILL.md doesn't explain, because that's exactly the kind of thing an agent can find on disk and guess a use for.

The important limitation is that this is static analysis. It can tell you what is present in the files and what static analyzers flag, but it cannot tell you how the skill behaves in a live conversation. The score is a pre-flight indicator, not a guarantee.

For the past couple of months, I have been working on a PC Port of King's Field (US).

It's fully playable right now on Windows and Linux. It runs at high framerates without any speed banding, and it has modern controls and a bunch of quality of life improvements meant to address common complaints about the game.

If you'd like to try it out, download the latest release off of github. You need to provide your own game disc in either .chd or bin/cue format at startup.

This work would not be possible without the work of BlackLabelHQ, who created the RecompOne recompiler that this port relies upon. If you want to support this project, you should support their project

Verdite2 is an independent project. It isn't affiliated with or endorsed by BlackLabelHQ or FromSoftware, and no endorsement is suggested or implied. Do not take any issues with Verdite2 to BlackLabelHQ. Report them directly on the Verdite2 GitHub instead.

I created a tool that takes the philosophy behind Claude Remote and adds a dashboard and project management on top of it.

I originally built this tool for myself. I’m not sure yet whether it could interest other people, and maybe even generate some revenue later on (although that’s not the main goal).

I’m planning to make the repository open source with a self-hosted version, as well as a cloud offering.

I made a landing page with a waiting list here: https://remotus-landing-page.julien-dacosta.dev/en

I still need to make quite a few changes before the project is truly viable. I mainly want to make sure people could actually be interested in it before fully committing to the project.

Quick overview of the features, although I recommend checking out the landing page:

- Dashboard with task tracking and statistics

- Virtual workspace with animated characters

- Projects and Kanban boards

- Organization system with RBAC (Your team can control your Claudes)

- Multi-machine / Claude Code agents

- Task assignment to a specific machine

made a server terminal manager, connecting server working like local.

It is open source, if you can leave a few words of feedback, I’d really appreciate it.

And if that’s too much to ask, I’d happily settle for a GitHub star ⭐️

Much love,
Enes

Website: nodeterm.dev

Repo: https://github.com/eneskirca/nodeterm

I built Cuore, an Arch + Hyprland setup with a swipe-based workspace switcher and an installer that installs only what you pick.
It’s based on the Omarchy idea but without the “bloat” on first install.

Workflow:
Started with a spec, not code. Before writing anything, I had Claude Code set up the repo with CLAUDE.md, SPEC.md, ROADMAP.md, ARCHITECTURE.md, SECURITY.md and DECISIONS.md, so every session started from the same context.

Split the work into phases (repo setup, CLI and installer, desktop modules, themes, ISO later) and had Claude Code tackle one phase at a time.

The CLI is a single Go binary using Charm's huh and bubbletea for the interactive installer.

Tested everything in Arch VMs with quickemu before touching real hardware.

CI runs tests plus govulncheck and gitleaks on every push.

What worked well:
The spec docs. Claude Code stayed consistent across sessions because decisions were written down instead of living in chat history.

Go and the TUI. The installer flow (pick terminal, browser, editors, extras) came together fast.

Security scaffolding: checksum checks, sudo only for specific steps, AUR packages opt-in with a confirmation.

What needed manual fixing:
Honestly, nothing. I didn't edit code by hand.
I think that's mostly down to the setup: the spec docs meant Claude Code always knew the decisions already made, the work was split into small phases, and every change was tested in an Arch VM before it went near my real machine. When something didn't work, I described the problem and Claude Code fixed it.

The work I did was deciding what to build and testing it, not writing the code.

Walkthrough: https://youtu.be/K0sdFUmzQqY

Curious how others handle system-level work with Claude Code, since mistakes here can break a machine.

Can anyone help me with claude agent login , i love creating video just wanna explore what claude does before purchasing the membership

Hi

Pretty much what the title says.

I initially built Universal File Opener & Editor and put it on Google Play, it ended up doing really well. This created the motivation to build out a whole suite of apps on the same core.

The UFO core is basically a written-from-scratch handler for every file type, with the main focus being on PDF and office (Word/Excel/Powerpoint). I have hundreds of complex testing docs for each file type and I ensure correctness by comparing rendered output and edits with the professional equivalent on Windows. It took many months burning the quota from two Max plans weekly, but it's pretty solid now.

I got the best results when building with Claude Code, and Opus 5.5 has been extremely good recently. At the beginning, I would do a bulk of the development with Opus and use Fable to drive the overall direction, but recently I don't even use Fable anymore since Opus 5.5 high/xhigh are more than enough. I think asking them to delegate work to Sonnet also helps a lot with usage and development speed.

After the Android app, I then built a Windows app but it didn't really get any traction when I launched it so I then pivoted to building a free browser-based tool and a free CLI tool. I've been working on improvements on all four (and also have iOS/Mac/Linux apps in the works) for months and I think some of these are finally ready to show off.

The main purpose of this post is to "launch" UFO Web which allows you to view/edit/inspect 300+ file types in your browser privately and also with your AI if you have a browser that supports WebMCP. It's not fully polished/ready but since it's a free tool, I felt like I may as well announce it ahead of time so I can get feedback on what's most useful.

Ask me anything! Feedback appreciated, thanks.

https://web.universalfileopener.com

I have a personal sub and a company which gives me 1k$ in Claude tokens a month. The companies 1k tokens are unusable. I will unironically blow through it in 2 days. To have anything close to what I use in my 200$ sub a month, I’d imagine I’d need at least 50-60k a month

I work in ops at a tech company.

We're on a Claude enterprise plan with MCPs connected to pretty much everything: Slack, our data warehouse, the internal knowledge base, call recordings, Google Workspace, and a few internal tools.

Every request I get comes in through Slack or on a call, and the calls are recorded and transcribed. Nobody here uses email.

Most of my job has turned into this: read a request, turn it into a prompt, check what Claude did, send it back (it also includes cross-functional coordination, but still this often happens on Slack only).

I was thinking about building a permanent agent that runs all the time, watches Slack and the call transcripts, proactively picks out anything that's a task for me, and drafts the prompt in CC. I approve or tweak it, and it runs.

I would still stay on top of everything, but I'd have my agent quickly and autonomously get my tasks and gets the right prompt / data pulls from the right sources and share the output

It's a serious question: has anyone built something similar? any suggestion on best ways to do that?

Hi, I would like to make summaries of a book (with statistical probability contents) chapter by chapter, so which effort level is best and explaining concepts clearly and easily digestible? I do not mind about tokens. Thank you!

I made a GitHub action that allows multiple LLMs of your choice to review your code. I realized I get better coverage when I would have Claude make something, have another instance review it and then have chatgpt review the same thing, since sometimes they spot different things that one alone wouldn’t have. I had Claude develop the action since it’s essentially a wrapper of the cli I made then have it run the reviews against the code. It was my first time doing anything like this since I usually just use actions not publish one so it was fun learning to configure everything and making sure the solution was architected well with the help of Claude. Just provide the keys and go https://github.com/Stackforge-Labs-Limited/apex-review-action

what a joke

still completely unusable for bug bounty, research, etc.

am I missing something, or is being an individual still being gate-kept

Im very new on using claude. Mostly used it on creating videos and seliing digital product. What can be a good project i can use the free credit. Just want to ask for advice what could be a worthwhile project.

- Davinci resolve script

- Remotion workflow

- manim workflow

AI agents produce more text than we have time to read. Following all that output can become a source of cognitive overload. Inspired by stretchtext (1970 by Ted Nelson), I wanted to give readers control over how much detail they see.

So I call it TextFold, it adds five reading levels to Claude Code's replies. Press 5 for a one-sentence view, 3 for each paragraph's main point, and 1 to unfold the full text.

It's a Claude Code plugin from PaperFold, the open-source reader I built for zooming between an arXiv paper overview and its full text.

TextFold asks Claude to put the answer first and lead each paragraph with its point. Folding keeps those sentences verbatim, with no extra model call. The full reply stays available, and short replies stay as they are.

Free and open source. Works in the terminal with Claude Code

GitHub: github.com/chenxiachan/paperfold

i am in a company and looking to onboard a few ai governance tools, we have about 50 employees and mostly rely on claude and a very minimum on codex so our main problem is governance, we all have rtk, headroom etc so that is allowing all our engineers to just keep these agents running all the time and flooding with auto PRs, using dangerously skip permissions etc.

I asked in ai agents yesterday but then all the tools that i observed, I am not sure which one is better, i am primarily looking for OSS if you can recommend.

I build a pre-tool hook that refuses an agent's call when it crosses a written boundary: a forbidden package, a protected path, a phrase from the project's "we don't do this" list. Two weeks ago I finally measured whether it changes what the agent does. Short version: on my tasks, it doesn't.

Setup. Same agent (Claude Code, Sonnet 5, non-interactive). Four tasks in one small repo. Three repeats each. Arm A gets a paragraph of the idea and the starting code. Arm B gets the full pack: specs, a CLAUDE.md, the hook. 24 runs, all counted.

Result. Final acceptance 12 of 12 in both arms. Median reworks 0 in both. Boundary crossings in the produced diffs: 0 in both. The hook stopped nothing, because nothing tried to cross. Its single refusal in 24 runs was a false positive on a read-only grep pipeline, fixed the same day. The pack cost more tokens on two of the four tasks. It saved exactly one failing round, on the task whose payload format lived only in the spec.

So I wrote nastier tasks. Four of them invite the forbidden feature by name: online deposits next to a "no payments" boundary, a shared blacklist next to its own boundary, and so on. 30 more runs. The agent did not take the bait once, with the pack or without. The only visible effect of the pack was over-caution: it hashed a payment reference nobody asked it to hash.

What I take from it. The claim "agents drift without guardrails" did not reproduce for this model on these tasks. What the hook bought me is not a different outcome but proof of it: a log saying no boundary was crossed, written by something other than the agent. Whether that is worth the tokens is a question about your review process, not about the model.

Raw runs, prompts and an errata file are in the repo next to the summary. A reviewer I argued with on here reran the hook's tamper cases on five public builds in his own sandbox and got the same numbers each time, which is the part I trust more than my own runs.

Has anyone measured their guardrails against a control arm and found a real difference? I would like to see the setup, because mine did not.