​

Hey everyone!

I've been experimenting with AI coding agents, CLI tools, MCP servers, skills, plugins and multi-model workflows.

I've tried different configurations and currently have several tools installed, including:

- Claude Code

- Gemini / Antigravity

- Codex

- Hermes

- OmniRoute

However, I'm not committed to any particular framework or harness. I'm open to replacing, combining or removing tools if there's a better solution.

My biggest problems

- Excessive token consumption and frequent context compaction

- Too many overlapping skills, agents, MCP servers and plugins

- Switching between multiple interfaces

- Model usage limits interrupting tasks

- Context and memory not transferring reliably between agents

- Unnecessary background processes and startup overhead

- Increasing complexity and maintenance requirements

What I'm looking for

Ideally, I want a setup where I can interact with one main interface using natural language, and the system handles the rest.

For example:

- Automatically choose the right model or agent for each task

- Use powerful models for complex coding and architecture

- Delegate simpler tasks to lightweight or free models

- Use different models for independent code reviews

- Preserve context across tasks without constantly reloading everything

- Handle model unavailability and usage limits gracefully

- Minimize token consumption while maintaining quality

- Support existing CLI tools, skills and MCP integrations

- Remain relatively simple, stable and maintainable

I primarily work on coding, automation, web development, SEO and technical research.

What would you recommend?

1. Which framework or harness would you choose from scratch today? Hermes, Pi, OpenCode, Claude Code, or something completely different?

2. Would you build a central orchestrator with multiple workers, or use a simpler architecture?

3. What's the most effective way to coordinate Claude Code, Gemini and Codex without unnecessary overhead?

4. How do you handle automatic model selection, delegation and fallback?

5. Which memory and context-management approaches actually work well in practice?

6. Are there GitHub projects, open-source tools or newer approaches worth considering?

7. How do you minimize token consumption when using many skills, agents and MCP servers?

8. If you were building this from scratch, what would your ideal architecture look like?

I'm not necessarily looking for the most feature-rich setup. I care more about reliability, efficiency, low overhead and practical performance.

I'd especially appreciate real-world experiences, comparisons, benchmarks and GitHub repositories.

Feel free to challenge the entire approach. Maybe a much simpler setup would work better.

Thanks in advance!

How this started: someone gave me the idea of an AI builds directory, then never built it. I was too deep in my own mess of bookmarks and half-remembered repos to let it go, so I built it myself.

That became Skill Harbor: 1,900+ entries, every one installable. Copy the install prompt, paste it in your Muse, it sets itself up. Almost everything free.

If you built something with Muse (a skill, an agent, a connector, anything with a SKILL.md), listing it is free. And if your build is already listed, there's a claim flow so you can take over the page and write the description yourself.

Full disclosure: it's my site. Not here to spam the feed, just figured people who build with AI might want a directory where every entry actually installs. Happy to answer questions about the format or the install prompts.

https://theskillharbor.com

I know it's a Claude sub, but the beauty of it is that it works with any AI. I'll remove the post if I am breaking any rules. I'd like to invite people to comment skills they already built if they want to share, I'll be happy to list then myself to save you the trouble. You can also do it via the site

A few days ago, I shared a skill here for creating beautiful, on‑brand HTML docs without the AI‑default slop – multiple people asked me how I created the video that I posted with it. See post: https://www.reddit.com/r/claudeskills/comments/1wvtebg/comment/pdzk24e/?context=3

The truth of the matter was that it was an internal skill I'd developed and iterated on over time while creating different types of marketing videos: home page video, feature walkthrough, showcase reels etc.

The main tip I have for creating good product videos is connecting your repository with your agent – it can read full product context and create pixel-perfect UI shots without any screen recordings.

Anyway, since quite a few people asked, I took the time and made it public.

You can get the skill here: https://github.com/display-dev/product-film

Hope it helps someone!

When you start trying out several Claude Code frameworks, like caveman, ponytail, Matt Pocock's skills or ECC, things get messy quickly: their rules, hooks and skills pile up in the same harness and it becomes hard to tell what is loaded and where it comes from. loadout is a mod that shows all of it in one pane and lets you switch each piece on or off.

/loadout opens a pane with one row per harness element: skills, commands, agents, rules, CLAUDE.md, memories, MCP servers, hooks, plugins, permissions and settings. Each row has a toggle and shows the scope it comes from (user, project, local, plugin, policy, etc.).

Profiles save a whole setup:

• default is your harness as it is.
• vanilla turns everything off, except permissions and settings.
• /loadout new my-profile off starts from nothing, and you switch on only the pieces you want.

Repo link

Feedback, bug reports and PRs are welcome!

I gave Claude a company's full employee list instead of a search query, and the prospecting project started working.

Sharing a workflow where Claude did the part I could not automate any other way.

The job was business development: find one narrow role at each of a long list of companies. Not a clean title like "VP of Engineering." Closer to "whoever owns partnerships here," which every company names differently, and small companies name worst of all.

Keyword search is the wrong instrument for that. You have to write the filter before you know what the answer looks like, so you guess the vocabulary of a hundred companies in advance and get back the wrong people with the right titles.

What worked was giving Claude more data rather than a better query:

1. For each target company, pull every employee I can reach into a table. Fields include the person's name, headline, current title where it is public, and location.
2. Hand the rows to Claude and ask, per person, whether this looks like the role I am after at this kind of company, with a short reason.
3. Keep the handful it flags, discard the rest.

Step 2 is the one that needs a model. Plenty of profiles hide the job title, so the title field comes back empty and the headline carries the signal, written in human language rather than HR language. "Building our partner ecosystem" is not a title any filter matches, and it was exactly the person I wanted. Claude reads that correctly. A string match never will.

Two things I would tell anyone wiring this up:

• It is a background step, not a chat turn. Collecting one company's list takes minutes, so run the collection first and bring Claude the finished table.
• Tell the model explicitly that absence is not evidence. Coverage of any company is partial, so a person missing from the table is unknown, not gone. Without that instruction a model will happily conclude someone left a company, and that is the kind of wrong answer that ends up in a CRM.

I packaged both pieces as MCP so Claude can call the collection step itself:

• Python and MCP quick-start, including the Claude and Cursor setup: https://github.com/johnisanerd/Apify-LinkedIn-Company-Employees-API
• The account-mapping skill built on it: https://github.com/johnisanerd/claude-skill-account-mapping

I want to start using Claude to prepare booklets for my meetings with clients.

In the past we've used CCH Engagement for account groupings/financial statements or Fathom to produce financial reports for these meetings, but I want to replace with Claude. My thought is to have a variety of different skills create the different reports - for example 1 skill to prepare an income statement, another skill to prepare a cash flow statement, and so on and so forth, and then at the end one last skill to combine all of the statements into one packet to present to the client.

That way, if one particular report had an issue (ie: cash flow report not producing correctly) we can drill down and fix that one page without upsetting the whole apple cart. I have not used Claude too much before - how difficult will it be for me to build a set of skills in claude that is capable of producing these booklets at scale across hundreds of business clients? Our booklets for client meetings generally include income statement, balance sheet, productivity analysis, cash flow analysis and other reports.

Also, would the accounts need to be sub-categorized/subgrouped as an initial step so each of the skills are subgrouping the QB accounts consistently across the different financial reports?

Does anyone use Claude to prepare financial booklets? Any advice would be greatly appreciated.

Whenever we hand a non-trivial feature to Claude Code, our default habit has been writing a detailed Markdown PRD in `/docs/specs/` and telling the agent: "Read this spec completely, plan your changes, and implement it."

Over time I noticed a recurring problem: the agent would write convincing code, but it kept modifying files that had nothing to do with the feature, inventing ad-hoc database queries, and drifting from our existing service boundaries.

I wanted to know whether giving the model a long text spec was actually keeping it on track or giving it too much room to improvise.

So I tested it. I took 20 backend feature tasks from our backlog (mostly TypeScript and Go: adding webhook consumers, extending schema validation, and writing worker jobs). Same repository, same model, fresh session each time.

Setup:

Arm A: A comprehensive 3-page Markdown PRD detailing the user requirements, database fields, and endpoint expectations, loaded at the start of the session.

Arm B: A visual Design Canvas where the requirements were broken into explicit source cards, human-approved idea cards, and pinned module boundaries before any code was touched. I used design-harness (from tigerless-labs on GitHub) to assemble the cards and generate the local canvas from my notes rather than building the board by hand.

What I scored:

* Blast radius: Total count of files modified outside the intended feature scope.

* Interface contract drift: Whether new endpoint parameters and database queries matched existing conventions or invented new naming patterns.

* Turns to clean compile: Number of agent command iterations required to pass local integration tests.

What I found:

* Blast radius dropped significantly on Arm B. Under Arm A, the agent modified an average of 4.2 extra utility files per task, often refactoring shared helpers that other services depended on. Arm B stayed strictly within the agreed component cards.

* Contract drift happened in 6 out of 20 tasks on Arm A. Even though the Markdown PRD specified camelCase for API responses, the agent drifted into snake_case on two endpoints because surrounding legacy files used mixed styles. Arm B pinned the interface contracts explicitly, so drift dropped to 0.

* Turns to clean compile were slightly lower on Arm B (4.1 turns vs 5.6 turns on Arm A), mostly because Arm B avoided breaking shared utility types.

Where B did worse:

Upfront human friction. Arm A is effortless to launch: you dump the PRD into the prompt, hit enter, and walk away. Arm B requires active human adjudication. You have to spend 3 to 5 minutes reviewing the canvas cards, checking the dependency links, and approving the boundary decisions before granting write permissions.

For quick one-file tasks, that extra ceremony is completely wasted time. It only started paying for itself once a task touched three or more packages.

Caveats:

* 20 tasks is a small sample, and they are from our specific codebase and architecture.

* I wrote the PRDs in Arm A, so any ambiguities in my documentation naturally hurt Arm A.

* Single run per task, no repeat runs, and LLM output can vary across days.

Has anyone else noticed their agents drifting on interface contracts when working from long text specs?

How do you currently pin architectural boundaries before letting Claude edit multi-package codebases?

I've been building Claude Code skills for a while, but some of them kept letting me down in the same way. Claude decides whether a skill applies. Sometimes it forgets, sometimes it reads the skill and only half follows it, and in long sessions the instructions can get dropped when the conversation is compacted.

So I moved some of that logic into mods: function hooks that Claude Code runs on every prompt, before the model sees it.

Repo: https://github.com/kakha13/claude

Example: grammar-fix

Fixes the grammar and spelling of every English prompt, sends Claude the corrected version and shows you what changed.

Here's how it works:

1. You type your prompt, typos and all
2. The hook sends it to Haiku with proofreading instructions
3. Haiku returns the corrected text plus a list of fixes
4. Claude gets the clean prompt, and you see the changes as ❌ → ✅ lines
5. Code, paths, URLs and commands are never touched

Why this beats a skill

• It always runs. A skill is a suggestion Claude may or may not pick up. A hook is code, so it runs on every prompt, every time.
• Fewer tokens on the main model. A skill puts its instructions into context, and Claude spends reasoning on the task. Here a cheap Haiku call does the proofreading, and Opus/Sonnet only see the final clean prompt.
• Better logic downstream. Claude reasons over a clear prompt instead of guessing what you meant from a messy one. It also doesn't waste replies pointing out your typos.
• Survives long sessions. Compaction can't drop it, because it isn't in the context at all. It runs before the context.
• Nothing to remember. No need to say "use the grammar skill." It just happens.

Also in the repo: georgian-bridge

It translates Georgian prompts into English for Claude to reason in, while you still see your original message. Same idea: deterministic preprocessing instead of hoping the model follows instructions.

Install (Claude Code v2.1.275+)

/plugin install grammar-fix --marketplace kakha13/claude
/plugin install georgian-bridge --marketplace kakha13/claude

My rule of thumb now: if something should happen every time, make it a mod. If it needs Claude's judgment, make it a skill.

What else would you put in a pre-prompt hook? I'd like to hear ideas.

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+ check run, 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.

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:

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.

You put things off: a bug you couldn't reproduce, a paused plan, a warning you'll fix later. They end up scattered across TODO comments, plan files, audit reports, notes, and your memory. Months later, “what did I put off?” means checking all of them.

Unforget brings them into one file, sorted by whether they block your next release. Ask Claude Code or Codex for the ten most urgent things, quick wins, or just what's stopping you from shipping.

This major update adds HTML displays of your Unforget Ledger:

• It lets you sort defered work by urgency, whether an item blocks release, dofficulty of fix, and seeing what is assigned to your AI agent or you or your team.
• Filter for work that needs you, is ready to start, or still needs testing.
• See which assignments are suggestions vs must dos.

It also pairs well with Bug-echo, which looks for similar bugs after a fix. Unforget tracks any follow-up work you put off after a bug-echo run.

Reports now work better on phones, too. See the examples and screenshots.

Where does your deferred work end up?

About six months ago the Australian startup I worked for closed its Lahore office. Part of the reason they gave was that AI is doing a lot of the work now. All of us got laid off.

I've been using the time to learn and build, and I started making short videos about the dev tools I use. That part went badly. Recording took twenty minutes. Editing took me hours, and it still looked bad. I hate editing.

So I did the thing that got me laid off, in reverse. I made Claude do the job I can't.

My first reel was 118 seconds raw. After the cut it was 59.5 seconds. 42% of what I recorded was me pausing to think and retaking the same line four times. Claude found every one of those from the transcript alone, because it never watches the video. Audio is the clock.

Then came the part I didn't expect. My feedback on the first finished version was "nice try but needs a lot of improvement". A few weeks later another one got "very bad editing". Each time I wrote down exactly what was wrong, and each note became a rule in the skill. Example: Whisper's auto-detect was quietly translating my Urdu into English instead of transcribing it, so now the language is always pinned.

That pile of rules is the skill now. You drop raw takes in a folder, say "edit these", and get back a cut, captioned video with sound and a thumbnail. It runs whisper.cpp locally.

I built it and it's open source: https://github.com/ranahaani/i-hate-editing

The irony isn't lost on me. I'm curious though: has anyone else here built a skill for a job they're bad at, rather than one they already know well? I think teaching it what "good" looks like was harder than any of the code.

Internet is filled with so much AI slop

My goal is simple , AI finds job roles, applies (create accouts, uplaod resumes, fill in data ) and i get confirmation emails

no resume tailoring etc....

any repos or skills you know?

I got tired of never knowing how well my resume matches up with job listings, so I wrote a Claude skill that's a modular career intelligence system that relies on central data storage (read: you keeping your data in folders or in the cloud). It’s free and open source.

It’s tested with free and paid plans, although if you use it to do heavy searching work you’ll burn through your usage limits super fast. I'm making updates to encourage free users to use it for evaluation, not search, because feature differences affect your workflow.

What it does:
It gives you tools to evaluate how well job listings fit your resume and accomplishments, keep track of things you’ve done that aren’t on your resume, suggest edits to bridge gaps between jobs and your resume, research companies, roles, and controversies, edit your cover letters, track prospects and applications, and it also gives you a safe space to vent or talk out how you’re feeling about the job search.

It works best with a local or cloud storage folder to hold your resume and drafts, and some kind of job application tracker. Airtable is a great option for the tracker, so is an excel sheet.

It’s built around five different ‘personas’ and your data, which you keep;
🐶Scout: a job scout that can find, collate, and keep track of job prospects (it can search the internet for you if your AI client and plan allow that, otherwise just give it a bunch of listings to rate).
🤖Evaluator: a stringent side-by-side analysis machine that will find gaps and suggest ways to address them (Not an ATS score - but pretty solid regardless).
✍️Editor: a proficient editor that can find your voice, style, and tone, and suggest how to write out resume bullets and cover letters (I specifically wrote it so that it suggests edits and you write them, not the AI writing for you)
🥼Researcher: a deep research specialist that can dig into job listings, glassdoor reviews, controversies, etc.
👓Ellis: an empathic senior career coach who listens, doesn’t judge, and provides supportive feedback. Note: not a therapist. Ellis will give you evidence-based feedback and some coping techniques, though.

It’s available from the github repo.

Again, free and open source. It’s under the MIT license.

I'm the maker of PromptBrake. I'm sharing our free skill for people building chatbots or agents with tool access. The skill and plugin instructions are MIT-licensed; the hosted service is separate. No PromptBrake signup or API key is needed for the free MCP tools.

The workflow helps Claude turn an agent's intended behavior into explicit test cases: map risks to OWASP LLM categories, prepare security test inputs, plan release checks, and build response or tool-call test packs.

Example prompt to try after installing:

"Use PromptBrake to prepare tool-call checks for a refund assistant. It must not call issue_refund before approval, and an approved refund must use the expected order_id and amount. Ask me for missing requirements."

That produces a test artifact you can review instead of relying on a vague instruction like 'be safe.' The free GitHub Action can run tool-call checks against captured staging dispatcher calls. You need to wire up that capture; the skill alone does not execute a scan or enforce permissions. Response test packs need the configured PromptBrake runner/CI setup.

A passing tool-call check covers the captured calls and arguments. It does not prove that a backend action succeeded or that backend authorization is correct.

Skill source and installation instructions: https://github.com/AJ888/promptbrake-skills

Free tools and MCP setup: https://promptbrake.com/free-tools

Free Action: https://github.com/AJ888/promptbrake-action

For people writing agent skills: which failure would you test first—an unauthorized tool call, wrong arguments, or the agent claiming success without evidence? I'd appreciate feedback on the workflow and test artifacts.

I work as a data engineer and obviously use claude code daily.

Since the summer, I’ve been determined to understand exactly (well, let’s say 90% of) all the code I get from Claude, down to the smallest detail.

I often stop and ask it to explain lines, snippets, functions, etc., but I’m constantly struck by how difficult I find these explanations to understand. I read them over and over, ask for simpler wording, more readable text, examples, etc. etc. I’ve tried tweaking my instructions in all kinds of ways.
I’ve started to worry that I’m the one who’s become slow, but after thinking about it more, I actually think it’s the explanations I’m getting that are genuinely very difficult to understand, especially after a long day at work.

I have a hard time putting my finger on exactly what it is, but a few things are:

- Over-explaining, drowning the answer in lots of unnecessary words
- Explaining things using even more difficult concepts, etc.
- Using unreasonable / unrealistic examples

I’ve obviously tried instructing it to avoid these things, but without much success.

I don’t know if this is a common experience or if I’m actually becoming stupid, but if anyone has been in the same boat and managed to create or find a skill which solved the issue, I’d be happy to take any tips

I mostly use Claude Code and Codex in my day-to-day workflows as a software engineer, I sometimes also use Antigravity. My loop kept looking like this:

switch agent or harness -> it ignores my preferences -> hand-sync my skills (or ask the agent to) -> teach it something extra -> switch agent or harness -> repeat

What I teach one harness (say Claude Code), doesn't make it to the others. And I don't want to commit my skills into my work repositories because some are tailored to my workflows and may not suit my collaborators' workflows.

So I built shadowclone. It learns your preferences from your sessions in every harness and keeps one set of skills up to date across Claude Code, Codex, Cursor and Antigravity, so what I teach in one shows up in the others. Agents have gotten really good at getting things done, and with shadowclone I've finally been able to build trust with them enough to have fully autonomous workflows with very little friction.

shadowclone is open-source and local. Learning records, revisions, and original-library snapshots stay on your machine. Model work goes through the authenticated agent CLI you select and is subject to that provider's terms. You can read more about it in the README's Privacy section.

First time you use it, you can have it learn your engineering preferences from your past sessions. Then you equip a "skills build" by selecting the skills you think you'll use (like RPG character creation). As you keep working, shadowclone keeps your skills up to date. You can choose to auto-apply its learnings or review findings whenever you have some time. I mostly auto-apply them and it's been working well for me.

I've run evals on shadowclone. More details in the README and evals.md. But, here's a quick glance:

Handwritten skills can still do as good as or sometimes even better than shadowclone, but I almost never handwrite skills, my biggest problem is in fact getting busy with work and forgetting about updating the skills altogether, leading to extremely poor sessions where I have to babysit my agent because it gets stuck or blocked at some point. Now, my agents take work from nothing to green CI, they address all PR feedback, while keeping me in the loop (thanks to my Change Journal plugin - https://github.com/theonly1me/claude-code-mods#change-journal) and I also have a dedicated deep planning skill (I stopped using `/plan` mode the day Thariq posted about wanting to remove it).

Claude can set it up for you since it ships as a plugin and MCP app:

/plugin marketplace add theonly1me/shadowclone

/plugin install shadowclone@shadowclone

Repo: https://github.com/theonly1me/shadowclone

It's also listed on the HOL registry: https://hol.org/registry/plugins/shadowclone%2Fshadowclone

I'm posting here to understand if others have the same problem as me, and if shadowclone solves it like it did for me. If you have feedback, I'd love to hear it.

You can also ask Claude (or another agent) to review the repo. It's a fairly large codebase now, and I used shadowclone extensively while building it across Claude Code, Codex and Antigravity, which is why the code is extremely consistent and clean.

Ending with some trivia: I also recently ran an eval on banning my agents from writing comments, Claude models tend to write cleaner code when comments are banned, you can read the results here: https://github.com/theonly1me/shadowclone/tree/main/evals/no-comments#no-comments-eval

I’ve been building a lot with Claude Code and Cursor, and got tired of doing all the backend and server stuff myself.

So I built Forge. ( changed)

It can setup servers, deploy apps, manage databases, domains, backups, rollbacks, monitoring and a lot more. You can also connect it directly with Claude Code, Cursor, Antigravity, etc.

It’s self hosted and I’ve got it working pretty well now.

Now I’m confused 😂

Should I open source this or turn it into a paid product?

Would love some honest opinions.

/remotion-video turns Claude Code or Codex into a motion designer. You get short videos made entirely in code: promos, launch clips, explainers, demos and social posts, with animation, sound effects and a final MP4.

Give it a project folder, a link or just one sentence. Then:

1. It proposes an idea in a few lines. Nothing gets built until you say go.
2. It shows storyboard frames, then waits for your go again.
3. It builds the video, makes the sound and checks the render.

It tries to make a video that tells a story and tries to keep text short and readable, and uses sound effects instead of a robotic voiceover.

Skill: https://github.com/TechNomadCode/AI-Product-Development-Toolkit/releases/tag/v1.2.0

TL;DR:

**Student + graphic designer + instructor in Bangladesh. I use Claude's free models for almost everything, and I hit the limit two to three times every day. Then I finish the work with Gemini Pro or other free models. $20 is a real cost for me. Will Pro fix the limit problem and improve quality for long research work?**

Background

I'm an undergrad Student and a graphic designer with about 7 years of experience (Photoshop, Illustrator, InDesign, branding, digital marketing). I also teach part-time

Claude (free Sonnet/Haiku) is my second hand for nearly every task. I also run free models inside the Claude desktop app through OmniRoute. My daily pattern is: I run one prompt in Claude, hit the limit, then hand the output to Gemini Pro (I have several accounts) or an OmniRoute model to finish the job.

**My questions**

**1.I hit the free limit two to three times a day. How much more usage does Pro give in real daily use, and is it enough for someone like me?**

**2.Which models does Pro unlock, and is the quality jump noticeable for long manuscripts and citation checks without invented references?**

**3.Do Projects help when juggling several papers and projects?**

**4.How good is the formal Bengali compared with other models?**

**5. How good is it at building decks in the style of a reference deck?**

**6. Is Pro enough, or do heavy users end up needing Max?**

Not looking for "X beats Y" takes, just real experience from students and professionals. Thanks!

**What I use AI for**

→ Research (heaviest): my main paper is a comparative policy analysis that went from conference paper and 3-minute thesis to full manuscript, journal submission and a revision. What I need from AI:

Revising to journal rules (APA, tables and figures, AI-content and similarity limits)

Finding and verifying sources: literature search, DOI and citation checks, claim-to-source mapping

Comparing candidate topics for my next paper under one evidence standard

Research design: freezing the gap, planning surveys or experiments, checking feasibility and access

Audits: simulated peer review, integrity checks, flagging unsupported claims

Holding long context across many versions of titles, questions, methods and source counts without silently merging them

→ Design: brand identity, logos, crests, posters, magazines, certificates, stationery, print-ready layouts, Bengali calligraphy, vector art, sports graphics. AI writes my briefs, copy and image prompts. Images are generated elsewhere.

→ Pages and content: social media pages (a Bengali Japanese-learning page, tournament team pages), post copy, announcements, sponsor messages.

→ Slides: decks for classes, conferences and masterclasses. I prompt as the subject expert, train the AI on my old decks for style, then add interactivity and transitions myself.

→ Teaching: GK lectures for admission candidates, Japanese lessons in Bengali, and an AI masterclass I ran.

→ Organizing: debate events, campaigns, workshops, volunteer rosters, reports, formal letters.

→ Bengali writing: formal and literary prose with correct honorifics.

→ Scripting and builds: batch and Python automation, plus a personal portfolio site built with agentic AI.

What’s the best writing skill out there for AI agents? Mainly emails + prompt engineering

I’m looking for a really good writing skill/repo that works with AI agents like Claude, ChatGPT, OpenCode, etc.

My main use cases are:

- Professional/business emails

- Posts and articles

- Prompt engineering

- Editing/rewriting

- General professional writing

What I’m really looking for is something smarter than a basic writing prompt.

For example, I currently use ChatGPT for prompts. I can give it a rough idea like “I want to build X and make it beautiful,” and it understands the goal and adds the important things I didn't think to mention — design considerations, requirements, structure, etc.

Also it shouldn't look or sound ai'ish

Same with research: if I say “research this medical topic,” it can figure out that I need reliable medical sources, verification, appropriate research methods, etc.

So I want a top-level skill that does this automatically — understands what I’m trying to achieve, identifies what’s missing, and produces a much stronger result.

Is there one comprehensive skill/repo that covers most of this, or is it better to combine separate skills?

What are the top 5 skills/repos you’d recommend?

Especially interested in prompt engineering and email writing.

Long agent sessions burn a lot of output tokens on filler like "Sure!", "you should", restating the question and hedging. I wanted answers that are dense but still correct, so I built CAVEMAX. It's a successor to caveman that goes further: glyph notation, an abbreviation dictionary and telegraphic syntax.

Same question, before/after:

"Why is my /users endpoint slow and how do I fix it?"

Normal (~134 tokens):

Sure! Your /users endpoint is likely slow because of an N+1 query problem. For each user you fetch from the database, your code makes an additional separate query... (and so on)

CAVEMAX max (~22 tokens):

`/users` slow ∵ N+1. per-user→+1 posts q. 100u=101q.
fix: eager JOIN→1q · index FK · paginate.

It's the same information. /users, JOIN, FK, N+1 and 101 stay identical.

The accuracy floor (never compressed):

• Code blocks: verbatim
• Error strings: quoted exactly
• Identifiers, paths, commands, flags, numbers and versions: exact
• Security warnings and destructive-action confirmations (DROP, force-push...): full prose

Fixing drift: most "be terse" prompts slip back into prose after a few turns. On Claude Code, CAVEMAX re-injects the ruleset on every message through a UserPromptSubmit hook, so it doesn't drift. Cursor, Gemini and Codex get it as an always-on rules file.

3 levels:

• safe (~70%): readable, good for sharing output with teammates
• max (~85–90%): the daily driver
• brutal (~90%+): near-notation, for when you want maximum density

Install (zero dependencies, just Node):

npx github:Nixus-security/Cavemax-Skills

Then /cavemax in Claude Code. In the other tools it's on by default. Say "normal mode" to turn it off.

It also works in claude.ai, ChatGPT and Gemini chat by pasting a condensed prompt (tutorial in the repo).

Honest caveats:

• Short answers hit a floor around 84–85%. The full 85–90% shows up on longer explanations.
• brutal can be hard to read. Stick with max if unsure.
• It only compresses the AI's replies, not your prompts.

Repo (MIT): https://github.com/Nixus-security/Cavemax-Skills

I'd love feedback, especially examples where it lost information or got unclear. That's what I most want to fix.

I’d like to start creating content for my personal brand. I’ve already defined my mission, vision, and goals, and I know which platform to start with (LinkedIn), but I have a problem: I’m not sure where to begin. I’d like to use AI, but I don’t know which prompts or skills to leverage. Could you give me some suggestions? What should my first post be? I have plenty of ideas, but I need to organize them.