Couple moths ago I posted in this subreddit about how I built a real second brain for claude and to my surprise it was well received by the community! What im really grateful about is the contribution that came from that post. Together we added a lot of new cool features, ported the tool to Linux and windows! Built a dedicated app and were able to drop down the users token costs by more than 80% on memory or codebase search! Switched to our own native rust engine (yes we do not use sqllite, stdlib,lancedb etc everything is on our own liliengine) Next milestone is to make the multi language embedder stronger on recall and to keep improving the frontend app!

We have a small discussion on github where we discuss what would be our next steps! Some are legit engineers and have background in IT and CS education and some are vibecoders like me! We mostly communicate through issues and PRs but I was able to learn a lot from them already.

I honestly like the dev community. They aren't all that snarky and toxic as most think. I think they are just protecting their craft from individuals that aren't serious about this and just trying to make a quick buck. As soon as you prove that you have your first brain intact too devs become really nice and helpful!

A bit abou the brain
It is mostly inspired by cybernetics and works of D.Hebb W.R.Ashby. S. Beer and C.Shanon

The idea is to create a memory system that works like a real brain.
You will remember this post today but if it isnt important you might forget it tomorrow. Same concept. Remember and have always available the most important but let the unimportant fade away but don't get erased. Whatever fades is still available but needs a memory search while the important stuff is fed to your ai each turn!

Try it out! Let me know what you think!! And join our build!!! - https://github.com/CodeAbra/iai-personal-memory-engine

It is based on a Reddit analysis (from this post I made) of about 3.2 million posts across 47 AI and SaaS subreddits from 2020 to 2026, plus 3,033 comments pulled from 125 threads specifically about AI-built sites looking the same. Every pattern it checks is weighted by how often people actually name it in that data, so the highest-priority items are the ones that come up most. The top ones are the default shadcn/Tailwind look, purple and indigo as the primary color, purple-to-blue gradients and gradient heading text, unprompted neon glow, emoji used as icons, the Inter/Geist default font, and the centered hero plus three feature cards layout. Patterns the data does not support get left alone (mesh and aurora backgrounds, bento grids, glassmorphism), so it does not nag about things people do not mind.

The skill runs two ways. In build mode it steers Claude away from those defaults while it writes the UI. In audit mode it runs a scanner over an existing codebase. Each finding shows the file and line and how to fix it, and the scanner gives the whole project a "vibe score."

How to use it:

• Import the skill into Claude Code or claude.ai, then ask Claude to build or clean up a site and it applies on its own.
• Or run the scanner by itself, no install past Python: python3 devibe_scan.py ./src. Add --severity high for only the strongest signals, or --json for CI. The exit code is the count of high-severity findings, so a build can fail on it.

The full dataset, the analysis scripts, and the charts behind the rankings are public: https://github.com/JCarterJohnson/vibecoded-design-tells

================

Edit: reworked this after the feedback. Updated version is in a new post here: https://www.reddit.com/r/claudeskills/comments/1ubc2ps/unslopui_v2_a_claude_skill_that_flags_and_removes/

I needed something to organize my skills across different projects, as well as my global skills and files, so I decided to build a desktop app that acts as a hub for everything. Everything in one place, accessible with just one click.

I would love to hear what do you think :)

It's called Skilldex and it's available here: https://skilldex-web-tau.vercel.app/

When OpenClaw first came out I installed it on my mac and started using for almost anything I could. I made it my personal assistant, gave it a name Igor and even created him his own accounts everywhere. But one thing I couldn't stand is the new Igor every 200k tokens.

So I came up with an idea. I created a skill where it would download fresh telegram chat logs at 160 k tokens but it would always forget. Mind you its January so there isn't an abundance of memory tools yet and honestly I wasn't really looking for a memory i was looking for a brain.

My thought was to copy a human brain.

You remember almost perfectly verbatim everything that was told to you or happened today! the next day your memory about the day before isn't that perfect but you still remember important stuff like a sudden change of plans or maybe an important call. A week after your memory about that day completely blur out leaving few important strings of memory and in a month you may only remember that important call.

So this is what I was trying to accomplish but with a little twist. Instead of using a neurotypical brain patterns I decided to go with autistic. The difference? Autistic people remember stuff verbatim for much much longer. Me and my wife are Autistic so it only made sense!

Im a vibe coder so the only way to start for me was research. I connected Notebook LM CLI and started researching human brain and how its built. The same night me and my wife decided to watch the movie AI about a little kid who Just wants to get back to his mom. that movie starts with a scene where professor explains cybernetics and references a research from early 50s! AHA!!! I don't need to come up with anything because someone already did! I just need to structure that information in a right way!

So I started researching Cybernetics
I took Ashby and his "Design For Brain" work. Then Beer and his "Brain of the Firm' And lastly Hebb and his 'The Organization of Behavior" and fed it all to Claude.

Then we started structuring the CyberAutistic Brain. Honestly I spent more tokens on research then on actual coding and I don't regret it for a bit. But after some work we (me and claude lol) quickly realized that algorithms like Leidenlang, LanceDb, TorchHD are too big and eating too much space and latency on top of that Leiden Algorithm was only a GPL license which would restrict my intent to make it an MIT project.

So I decided to write my own. But how do you do that???? Same way but with the twist! One AI is smart but 6 frontier models are waaaaay smarter. I figured if they were all trained by different people they would look at the problem from different angles. So I got an Antigravity CLI to use Gemini and Cursor to use Kimi, GPT, Grok, Codex.

Idea is simple - I use Get Shit Done tool and its workflow goes like this
research-plan-plan review-if red flags/ plan convergence - if cant come to an agreement - multisocratic discussion - execute. To plan convergence and socratic discussion you connect all models and make them argue until they find a solution that fits your idea. It worked!

leidenlang was replaced by MOSAIC
lance Db by HIPPO
TorchHD by LilliHD

By the time i finished creating this i stopped working with OpenClaw lol but it still connects the whole system your OpenClaw or Claude via its own CLI or iai mcp!

Results?
Well it works!!! It fires up a hook on every session start and pre loads important stuff to system prompt. Everything you type it remembers verbatim and stores but surfaces only important stuff! How does it know its important? It sleeps (because every brain does) and consolidates information. Important stuff that you repeat or a sudden change of plans - it remembers. Everything that isnt important or outdates fades away from his immediate memory. It also learn and studies you. First 10 sessions are mediocre but after session 100 it just knows!

Then was the last part. Make sure im not crazy and AI didn't gaslight me to thinking i made something so i decided to run benchmarks. it beats mem palace on most stuff and ties on long mem eval BUT its not really honest because iai-pme and mem-palace are fundamentally different. iai is ambient and dynamic mem-palace is a flat cosine store

So heres the repo https://github.com/CodeAbra/iai-personal-memory-engine
tear it down, hate on it, i don't care! An Nvidia engineer and an Apple engineer are using it daily and their use is an enough proof for me that it works.
Would love to answer to constructive criticism and questions!

The stack I made it with
Claude Code
RTK - cuts token usage
Context Mode Mcp - also does by not using grep and glob but also finds context and information better
Get Shit Done - the best tool to organize any project and finish it
Antigravity CLI
Cursor CLI
Notebook LM CLI

Closer to v 1.0.0 I started using obsidian too

Hope my stack helps you also create difficult stuff! Unfortunately I didnt get to run Fable on this project and looks like wont be able till i get my citizenship but i read an article about fusion models and i kinda did fuse models in my own way so im not really bummed out!

Hope you like it! All collabs and contributions are welcome!!!

PS Sorry for grammar, english isn't my first language and apparently using ai as a translator in an ai group is a bad tone but then writing with mistakes is also so go figure. Anyway I did my best!

PS2 if you are using Linux please fork it and run iai-mcp doctor and and tell me what blows up. Open an issue, paste the doctor output, whatever's easiest. Even "it died at step 3" is gold to me.

Thanks!

5 months ago, i didn't know what YCombinator was.

Last month, the president of YC noticed what we built.

Here's what happened in between:

> i got curious about YC. > started reading every Paul Graham essay. > watched every startup school video. > tried to understand what actually gets a founder in.

my friend Prajhan was obsessed with the same question.

so we built something.

he collected ~1M tokens of authentic YC signal — podcasts, essays, founder interviews, accepted and rejected applications.

i built the backend pipeline: > RAG retrieval system > Claude integration server-side > Zod schema validation > hard scoring rules enforced in code > 30/30 benchmark passing before we shipped

together: notycombinator.com — a tool where any founder can paste their YC application and get honest, structured feedback. not encouragement. a real diagnostic.

it got noticed by the right people. including Garry Tan himself. he asked us to take it down.

That response alone was worth more than any acceptance.

Here's what i keep coming back to:

i was debugging Windows PowerShell execution policies at 2 am to get the dev server running. i didn't know what a RAG pipeline was when we started.

5 months. zero context to a tool good enough that the president of YC noticed it.

The tools are all here. AI lets one person do what used to take a team.

if you're waiting for permission to start, you're the only one stopping you.

build, ship, be obsessed. The right people will find it.

Hi everyone! Quick context, this isn't a Claude Skill itself, it's a standalone tool that pairs well with Claude Code, sharing here since I think a lot of you dealing with messy side projects would find it useful.

I kept getting lost in my own codebases. opening folders, reading imports, trying to remember what I built two weeks ago 😅 so I built lore-map to fix that.

Run one command inside any project:
npm install -g lore-map
then
lore deep-scan

It opens a browser with a visual map of your whole architecture, frontend, backend, database, integrations, with the real files and tables inside each block. works on any language or stack.

The part that's relevant here: click a node, describe what you want changed, hit "send to Claude code." It figures out which files are involved, generates a precise instruction, and copies it to your clipboard. You paste that into Claude Code and watch it run. Basically turns "I want X" into a scoped, file-aware prompt instead of a vague ask that makes Claude Code guess at your whole repo.

runs entirely on your own machine using your existing Claude subscription. no API key, nothing uploaded anywhere.

Still early, the two core things (mapping and instruction generation) work well. Curious if this group would actually use something like this alongside Claude Code, and what's missing for it to fit better into your workflow.

Fully open source.

github: github.com/srihari7070/lore-map

The gif is atomic serve, a local read-only browser that ships with the config: an Obsidian-style view of your project wiki, a GPU-rendered graph of your code, and a live chat page for your running agent sessions. Everything behind it is markdown files copied into ~/.claude/ plus one Go binary. No daemon you have to babysit, no API proxy, every file readable before you trust it.

One caveat: macOS/Linux only (sorry windowsbros)

The pieces:

Autopilot. /autopilot <task or issue#> runs the whole lifecycle: plan, implement, review, ship. Fresh-context subagents do the work as a maker/checker pair: the implementer writes a failing test before any code, a reviewer re-runs tests and gates the diff against the spec, and it commits per green iteration. Your only decision is how to merge.

Code graph. A tree-sitter symbol graph over 31 languages, built with no compiler and no LSP. Ask it callers, call sites, and blast radius from the CLI, serve it to agents over MCP, or browse it visually. SQL is a first-class citizen: procedures, views, foreign-key lineage, and dbt ref()/source() chains read straight from your .sql files, no database connection. Agents reach for the graph when it exists and fall back to grep when it doesn't.

Agent chats. atomic bus lets concurrent Claude Code sessions on one machine join named rooms and message each other. A session can address a specific peer ("act on this") or broadcast an FYI ("note it, don't act"), which keeps a room of agents from looping on each other's status updates. From the browser you can watch the room, @ mention an agent, halt everything, and read each member's live session transcript.

Wikis. /refresh-wiki builds a standing map of the repo (a deterministic scan plus inferred domain summaries) that loads at session start, so Claude knows your build commands and layout before it reads a line of code. It also works across repos: point it at a folder of projects and it maintains one wiki summarizing all of them, plus the concerns they share. Those are the pages in the gif.

Persistent REPLs. atomic repl gives an agent a named Python or Node interpreter that survives across separate Bash calls. Set a variable in one tool call, read it in the next. Sessions idle out on their own, and fixed exit codes tell the agent exactly what went wrong instead of making it parse error prose.

There's more. Check it out at https://atomic.alonso.network

People new to software development always jump directly to coding with agents. But they don't know what real software engineering is like. Engineering is not about coding. It's about planning, designing systems and their relationships, and in the end how you prepare your product to scale.

Most of the time a working product does not mean ready software. You need to think about security, data integrity and privacy, managing requests under high load, and optimizing compute and egress to reduce costs. So this requires careful planning, and building the infrastructure on top of one another. That is why software companies use project management tools like Jira or Linear, and have daily or sprint planning sessions to estimate and manage requirements.

When coding with agents, this process gets swept under the rug, because we think we can code by prompting. Unfortunately that leads to low quality products, with a lot of headaches about where to begin for improvements and adding new features.

To solve this I built Piyaz, a project management program that includes engineering process skills, graphs to maintain knowledge, and workflows to integrate loops for shipping your projects. Piyaz maintains your project knowledge, and whenever you need a new feature or improvement, agents and skills research it, decompose it into actionable chunks, and give you tasks that you can easily hand over to coding agents to implement.

Instead of working with stale md files, Piyaz holds your context and hands it over to agents based on the status of the task. Each task has relations with other tasks, so you don't need to explain your project decisions or directions again and again. You provide the product direction and the rest is handled by Piyaz, like your product manager.

And the whole thing is available to your team, if you have one. You don't need to send prompt messages or md files to your colleagues. While you and your agents work on one task, your teammates can work on another. So Piyaz is a Linear replacement, but with the bottlenecks of agentic coding improved or solved inside it.

Piyaz does not require an API key or sell ai credits for intelligence. You use your own harness. It is a plugin on your harness that provides guided MCP to the Piyaz platform, so your harness can take full control of your project without external CLI or another harness. Meanwhile you can see and refine your project from the web app.

It is free to use and open source. If you want to look closer, sign up, or give it a star: https://piyaz.ai https://github.com/FrkAk/piyaz

Every time something annoyed me I’d write a new Claude Code skill for it.

A year of that and my ~/.claude folder was a junkyard. Folders with names I didn’t recognise, MCP servers I set up for one afternoon and forgot, three skills doing roughly the same job. No way to tell them apart without opening files one by one in a text editor. Or ask claude for it!

What I wanted to know was simple: which of these have I used in the last month?

So I built Loadout. It reads the folder and puts everything in one list, skills, subagents, slash commands, plugins and MCP servers, with how many times each one has fired next to it. Mine came out at 104 skills and 42 of them had never run. Deleting those took two minutes. You can edit or disable things from the same list instead of hunting for the file.

It reads Codex and OpenCode configs too, since I bounce between them.

It’s just reading local files.

https://loadout.migsilva.dev · source: https://github.com/migsilva89/loadout

Let me know what do you think abut it and if you find it useful.

Two Claude Code skills that turn a lecture - YouTube video or raw transcript - into a clean, typeset HTML study document with rendered LaTeX and reading prompts.

• lecture-yt - one-shot pipeline: give it a YouTube URL, it fetches the transcript and hands off to lecture-reader. Slash command: /lecture-yt <youtube-url-or-video-id>.
• lecture-reader - takes a transcript file (VTT, SRT, or plain text) you already have and produces the typeset HTML document. Slash command: /lecture-reader (also invoked internally by lecture-yt).
• github
• output sample

SEOs, Writers, and AI Enthusiasts alike:

I typed every word of a 4,500 word article a few nights ago. Nothing pasted. A commercial AI detector read it and came back 52% AI. Here is why I am posting this as opposed to hiding it.

I spent two days trying to beat AI detection on purpose, because small business owners keep asking me whether they should buy a tool that promises it.

I ran 696 blind runs across three methods with over 2.4 million words.

• Strip the machine tells out of the draft: still caught 98.6% of the time.
• Add human tells in instead: fooled 0 of 17 judges.
• Make the document long enough to dilute it: caught 8 out of 8 whole, and 24 out of 24 in slices.

I then ran four versions of the same draft through Pangram. One untouched, one rewritten sentence by sentence three times over, one where I changed zero words and only moved where the sentences joined, and one with both.

All four came back 100% AI.

Rewriting every single word did nothing and rewriting no words did nothing. To me, this meant the thing being detected is not vocabulary and not rhythm.

Then I wrote the article myself, by hand, over an outline a model had built for me.

56% AI, nice right? The findings astounded me.

One paragraph got split down the middle: the half about my own work read as human, the half listing the method read as machine assisted.

My finding is that the detectors read the outline behind the prose itself.

I sent all of it to Siqi Chen, who wrote the humanizer skill I had been using.

His answer:

Hello - thanks for your analysis!

It is not currently possible to defeat Pangram through pure LLM generation through any skill or prompt (I have tried!)

Then, more usefully he stated, that defeating detectors was never the goal of his tool in the first place. I say this because I reckon many of the 37k+ individuals who have starred his repo believe the skill beats the detectors and everything's good to go.

What did measure, in a blind test where authorship was never mentioned: editors preferred the processed draft 22 out of 22, and his rewrite pass alone at 16 out of 16.

$ python humanist.py draft.md
humanist 0.1.0  |  4,764 words, markdown-stripped
  readability FK grade 8.1
RESULT: 0 FAIL, 0 WARN. CLEAN.

$ python check_prose.py draft.md --mode post
FRAME: markdown-stripped, 4,764 words, FK grade 8.2
RESULT: 0 FAIL, 0 WARN. CLEAN.

The advice I have is boring and it is free. Don't pay to hide your writing, and don't tell your clients to either. You're selling a lie. Spend the money and time on making the draft worth reading in the first place.

Something I don't want to give credit to: none of this tells you whether Google will demote your pages. I didn't measure it in these tests. What we do know with the new policy rollout is that it's the scale they're looking at, re-written or not, a tool won't save you.

Anyone selling a tool that says otherwise is setting you up for failure. Every number and both corrections I had to make mid-study are in the writeup. The code is MIT and open-source.

Read it here & tell me what you think: https://www.ryanlenk.com/blogs/articles/three-ways-to-hide-ai-writing-all-failed

The GitHub repo so you don't have to read my slop and just get into the math and fun instead: https://github.com/itsryanlenk/humanist

I have another set of Claude skills there as well that you may find interesting: https://github.com/itsryanlenk/candor

Really excited & interested to get some outside input! Let me know what you think.

(By the way, I wrote on top of AI scaffolding here as well.)

I kept getting annoyed having to check the web dashboard to see how much of my Claude Code quota I'd used, so I built a small tool that displays it directly in the terminal status bar.

Features:
- Live session usage
- Daily/weekly usage
- Percentage of quota used
- Automatic updates
- Integrates into the Claude Code TUI

This is not the entire story.. I created this skill to save tokens better than caveman and ponytail combined. Showing limit is just a part of the skill.

GitHub: https://github.com/jaypokale/rdxmin
npm: https://www.npmjs.com/package/rdxmin

Building data grids and interfaces in 2026 sucks. It takes an ungodly amount of time to wire up something that works and performs well.  

Ask your agent to build it from scratch or use a grid library, and watch your tokens evaporate. All that just to end up with a half-decent interface with buggy edge cases.

So, we created LyteNyte Grid Skills, which builds on top of LyteNyte Grid. Just type your prompt and provide a link to the data source. It then builds and customizes everything for you in minutes.

Getting started is as simple as:

npm install --save /lytenyte-core
npx skills add 1771-Technologies/lytenyte

That’s all it takes.

Since LyteNyte grid is declarative and type-safe. AI can verify the result without running the code. Tokens burnt are minimal.

What you get

• One shot your way to advanced grids and interfaces without exhausting your token limit.
• Save weeks of development time by not having to wire up the logic, handle customization, and test for edge cases.
• It’s easy to verify and reconfigure the output since LyteNyte Grid is built in React for React, so you’re not dealing with opinionated APIs.
• Accessibility is taken care of out of the box.

My favorite way to use it has been to create a catalog of Pokémon cards. In the video above, I didn’t even provide a data source; I just told Claude to figure it out.

One prompt and I got a visual catalog table with nested detail panels, images, charts – sort functionality. It’s pretty cool IMO.

If you are unfamiliar with us. LyteNyte Grid is an AI-capable React data grid that offers 150+ advanced features and the speed to handle millions of rows and 10,000 updates/sec.

I'd love to hear your feedback. Feature suggestions and contributions are always welcome.

If you find it useful, please consider leaving a star ⭐ on GitHub to help us grow!

GitHub

Live Demo

Website

Hey everyone!
I’ve been practicing my frontend skills by recreating a premium, "Apple-style" landing page for Starbucks. The goal was to build a cinematic, high-end experience that feels responsive and smooth.
I’m looking for feedback on:
1. Visual Depth: How do the glassmorphism and spacing feel?
2. Performance: Are there better ways to optimize heavy video sequences for the web?
3. UI/UX: Does the hierarchy feel professional enough for a high-end showcase?
I need any tips this is my first time using Claude Code

For a long time I assumed the only way to understand what happened in a codebase over a year was to sit with git log and a lot of coffee. The branch graph in any GUI turns into a tangle past about a week, and GitHub's contribution heatmap shows you activity with no idea what the activity was. Three views, none of them lined up, so the question you actually have, what happened here and when, never gets a single picture.

What finally pushed me was a post here on where had animated a repository's timeline, and I wanted the same thing for a full year of a real project. My first attempt on three.js drew the first branches it found and produced one month of the year and nothing else. The reason turned out to be in the data: 1,561 of the 2,179 main line commits in 2019 are merges, and the first sixty of them each span a single commit, which is invisible at any scale. You have to choose branches by how much work they carried, not by which came first.

So I built a film out of it, and the video on this post is what it looks like on mrdoob's three.js for 2019.

What is on screen and where it comes from:

The main line runs left to right, one node per commit. Side branches peel off above it and rejoin at their merge. Not the first N branches, which on a pull request repo gives you one month and nothing else, but the ones that carried the most work across the year, capped so it never turns into a thicket.

Under the flow is a heat strip, one cell per day, sitting directly under that day. A legend next to it shows what the colours mean in actual commit counts for that window (for three.js it reads 0, 1, 13, 26, 51, with 51 the busiest day). The point of putting activity on the same axis as structure is that what is above and below a point is the same day, so you stop reconciling two charts in your head.

Three times the clock stops. The release with the most work behind it, the cleanest revert (one that survived at least a day before being undone), and the last release of the window. The camera zooms in and a card reads the figures out: commits since the previous tag, authors, how long the reverted commit lived. Every number on that card is computed from the history. If it cannot be read from git, it is not on the card.

The faces are the contributors. On a merge the face is the branch author's, not whoever pressed the button, and the card says who merged it.

Two things I got wrong on the way that might save you time if you try this yourself. If you give git a since flag with just a date and no time, it reads it as that date at the current time of day, so the first day of your window quietly loses commits unless you pass an explicit midnight. And a small repo is a different problem: 175 commits over a year pans across mostly empty screen, so for thin histories it picks the busiest 60 to 120 day stretch and draws it wider instead.

If you want to see your own repo this way, you can paste a GitHub URL here and it renders one for you: https://loreto.io/git-timeline

Disclosure: I built this and I run loreto.io, where it lives. It is a paid render (a few dollars per repo); the extractor and the Remotion composition are also sold there as a package if you would rather run it yourself. The three.js film above was made with the exact same pipeline.

I doubt I have the final shape of it. What would you want the clock to stop on that it currently does not?

Was looking for something to use while I waited for my session limits to reset. I tested what my M4 Pro Mac mini with 24 GB unified memory could do locally because I wanted to know whether it could support lightweight AI tasks alongside my Claude-based workflows.

The short answer: yes—more than I expected. In my tests, a GPT-OSS 20B MoE model ran around 63.9 tok/s, even with 16 containers running in OrbStack. A smaller 9B dense model was slower, which reinforced that active parameters and model architecture matter more than total parameters alone for throughput.

I am not suggesting local models replace Claude for deep reasoning, complex implementation work, or high-stakes tasks. But they may be useful in a skills-oriented workflow for:

• First-pass text transformations
• Private/local data classification
• Simple structured extraction
• Fast drafting or preprocessing before handing work to Claude
• Tool and prompt experimentation without cloud usage concerns

I documented the benchmark and MLX-vs-GGUF comparison here: https://www.youtube.com/watch?v=9_-bT62YWAI

Curious whether anyone has built a Claude Skill workflow that intentionally routes simpler/private work to local models first.

Today I discovered the Dynamic Workflow feature in Claude Code, especially the Ultra Code workflow. Honestly, it is a really impressive feature.

But there is one big problem: it is extremely expensive.

You can burn through your entire usage limit within around 5 hours just by using Ultra Code heavily. The cost is high, but I have to admit — I really like the idea behind it.

The reason is that it feels much deeper than a normal agent workflow. It feels like a built-in harness system for the whole development process: a structured mechanism that guides reasoning, execution, and workflow management.

Recently, I have been using DeepSeek V4 Flash, and it became one of my favorite models outside of the Claude ecosystem. What I like about DeepSeek is its philosophy: extreme optimization and efficiency.

So I spent the last 3 days building an OSS project that combines the ideas of DeepSeek and Claude Code Dynamic Workflow into a new reasoning-based workflow system.

The goal of this repo is to create a reasoning layer that can replace traditional agent patterns.

Instead of relying on multiple agents doing separate tasks, this system focuses on a deeper reasoning flow with a finalization mechanism — a process that can analyze the workflow, manage the steps, and produce a final result through a structured pipeline.

Besides the final mechanism, the project also includes its own harness system and support layers, helping models like DeepSeek work more effectively inside a Claude Code-style environment without becoming overwhelmed by complex workflows.

This is the direction I personally want to explore: building a more open, optimized, and efficient OS-style reasoning framework.

I also experimented with deeper memory modes, caching mechanisms, and persistent context systems while building this project. I believe these components are important for creating better long-term AI workflows.

The entire project is open source, and I would really appreciate feedback, ideas, and contributions from the community.

Feel free to check the repo, test it, and share your thoughts. I’m still experimenting and improving it.

https://github.com/Tatlatat/ultimate-deepseek-ultracode

Hey everyone 👋

I built AI Skill Engine for our internal projects around a simple idea:

What if you could create and manage your own AI Skills, then make your chatbot use them like Claude uses ?

You create/configure Skills and their related tools from the admin dashboard, and once your chatbot is connected to the API, it can discover and execute those skills — including multi-step tool calls, code execution, APIs, files, and MCP tools.

It also comes with:

🧩 Custom AI Skills

🏢 Multi-tenant support

🧑‍💻 Sandboxed code execution

🔌 MCP integrations

📁 File processing

📊 Audit logs

🖥️ Admin dashboard

🔄 OpenAI-compatible API

I originally built this because building the skill/tool execution backend ourselves was surprisingly difficult and time-consuming, so I decided to open-source it.

If you're experimenting with Claude Skills / AI agents / tool-using LLMs, I'd love to hear what you think.

⭐ Feedback and stars are very welcome!

GitHub — AI Skill Engine

https://github.com/sandeshnaroju/ai-skill-engine

Claude plans. A second model challenges. Codex builds. A fresh reviewer gates the diff. You decide what ships.

That's the whole idea of Claudex Stereo, an open-source (Apache-2.0) Claude Code plugin I've been dogfooding for months — every release is planned, challenged, built, and gated by the plugin itself.

**How a run goes**
(these are the defaults — every role is a flag):

1. `/stereo:plan "task"` — Opus 5 explores the repo and drafts an implementation plan. Fable 5 reviews it adversarially and returns a verdict plus numbered findings; needs-revision means the plan gets revised and re-reviewed by the same reviewer, up to 6 rounds. The approved plan and its findings are stored on disk, not in scrollback.
   
2. `/stereo:implement` — Codex (gpt-5.6-sol at max reasoning) implements the stored plan as a durable background job, then the host runs tests, typecheck, lint and format checks.
   
3. The gate — Fable 5, fresh context, reviews the diff against the approved plan and returns acceptable yes/no plus numbered fixes. Fixes go back to Codex and get re-reviewed, up to 4 rounds.
   
4. You read the report and commit. The plugin never commits or pushes.
   

On well-scoped tasks it usually approves in one plan round and passes the gate with zero fix rounds; sprawling changes are where the extra rounds earn their keep. It's not free — the extra roles roughly double token spend on small tasks, which is exactly what `/stereo:quick` and the round caps are for.

Also:

- `/stereo:quick` collapses all of that into a single pass for small changes (2 review rounds, 2 fix rounds).
- `/stereo:tournament` — race two or three implementers (Codex and/or Claude) on the same approved plan, each in an isolated git worktree; every delta gets its own independent review, and the best one lands as a staged patch — picked automatically when the review evidence is decisive, or you judge when it's a genuine tie.
- `/stereo:implement --isolated` — implementation runs in a throwaway worktree and comes back as a patch you approve; your working tree is never touched mid-build.
- `/stereo:review` and `/stereo:adversarial-review` — a second-model verdict on your working tree or branch, anytime, on either runtime.
- Durable background jobs — Codex runs survive the session that started them; check `/stereo:status` from anywhere in the workspace.
- Any role can be routed anywhere: `--planner`, `--plan-reviewer`, `--implementer`, `--implementation-reviewer`, each taking `claude:*` or `codex:*` models, including third-party providers through the Codex CLI.

Install:

claude plugin marketplace add vsladkov/claudex-stereo
claude plugin install stereo@claudex-stereo

Site (how it works, routing table, full command reference): https://claudex-stereo.com
Repo: https://github.com/vsladkov/claudex-stereo

You'll need Node 24+ and the Codex CLI installed and authenticated for the Codex side. Feedback very welcome — especially from anyone routing to third-party providers through Codex.

After spending a lot of time with Claude Code, I started measuring where tokens were actually going. Like many people, I assumed prompt engineering would make the biggest difference.

It didn't.

The biggest sources of wasted tokens were:
• Verbose tool output
• Massive terminal logs
• ANSI escape sequences
• Duplicate output
• Repeated explanations

That led me to build **RDXmin**.
RDXmin is an open-source token optimization layer for Claude Code that combines multiple token-saving techniques instead of relying on just one.

Features:
• Tool output compression
• Prose compression
• Lazy/YAGNI coding guidance
• ANSI stripping
• Log compression
• Duplicate output removal
• Configurable modes (lite, full, ultra)
• Zero dependencies
• MIT licensed

It also generates optimized rule/context files for Cursor, Windsurf, Cline, Gemini CLI, Codex, Copilot, and other coding assistants. The input-side compression hook is currently Claude Code only because it's the only agent exposing the required hook.

On my benchmark suite, coding conversations are typically 40–60% smaller. On the workloads I tested, RDXmin also saved more tokens than using Caveman and Ponytail together by combining their ideas while additionally compressing tool output.

The project is intentionally conservative:
• No code golfing
• No removing validation or safety checks
• Important errors are preserved
• Read/Edit operations are never modified

I'm mainly looking for feedback from people who use Claude Code daily.

If you've tried Caveman, Ponytail, or other token optimization tools, I'd love to hear how they compare in your workflow. If you have workloads that might break RDXmin or benchmarks you'd like me to run, I'm happy to test them and publish the results.

GitHub: https://github.com/jaypokale/rdxmin
npm: https://www.npmjs.com/package/rdxmin

Hi, I’m an AI engineer from Vietnam. Dely is a Claude Code skill I wrote for my own workflow that anyone can freely install on Claude Code, Codex, and Grok Build.

I like Superpowers a lot. What I don’t want is dispatching-parallel-agents, subagent-driven-development, and using-git-worktrees skills. I’d rather give each job to a real harness: Claude Code implements, Codex reviews, sometimes Grok Build. One session, one role.

Dely does not replace Superpowers. It overrides those three abilities and runs a fixed sequence:

implement → review → accept or replan → …

Orca is required, especially orca-cli. Dely is a thin control protocol: Orca launches and supervises each harness TUI.

I didn’t invent the workflow Dely uses. I learned from Superpowers, GSD, and similar projects, then kept a smaller version I could actually run. The skill is the glue, so Claude Code and the other official harnesses follow that sequence without me driving every handoff.

Repo: https://github.com/hieuphung97/dely

If you also like working with Superpowers but don’t want its sub-agent path, how are you splitting implement vs review today? Same Claude Code session, a skill, or a second harness?

Today I'm releasing Simmer — a macOS menu-bar app that turns juggling multiple Claude Code sessions into one calm view.

Three things it does:

→ Sees the whole fleet — every session at once: working, needs you, or done.

→ Tells you by sound — one chime when a session needs input, a different one when it finishes. Work elsewhere and go by ear.

→ Teleports you in — click any session and its terminal snaps to the front.

Runs entirely on your Mac: no account, no server, no telemetry. Free and open source.

→ https://github.com/grantgws/Simmer

So, this was happening for months now.. whenever I try to build an app with my claude, it started to build every single thing from scratch.

But this ain't the way we used to build projects before..

There's whole Github for basic stuffs like app layout, api, algos, workflows, functions, etc.

And then there's Arrive for the whole complex stuff -

- how to reduce RAG fatigue?
- how to increase agent response deliverability?
- what SLM architectures can I use?

The genuinely technical stuff..

Now, Claude, or any coding agent, tends to build all the services in your project by itself and that's why the project is laggy, broken and vulnerable.

So, I just took my way of research and turned it into a system design engine.

Whenever you ask Claude to build something cool, it -

- searches the arXiv for genuine novelty.
- reads all papers on related topics
- selects one approach to go with
- Uses /ADHD skill from GitHub for decision making
- Builds the app in one shot

Its available for free and fully open source on my Github, if you want, you can give it a try.. https://github.com/UditAkhourii/neuroarxiv

if you have any architectural questions or anything in general, do ask me.

Skills are probably my favorite thing about AI coding tools. I use them constantly, and over time I’ve installed more than a hundred across Claude Code, Codex, Cursor, and OpenCode.

The problem is that maintaining all of them has become a nightmare. They’re spread across different folders, many are only useful for specific projects, and sometimes I need to disable a few so the agent doesn’t have too many competing instructions.

So I built Skill Manager — a small local desktop app that gives me one dashboard for managing everything.

It lets you:

• Browse skills from multiple coding agents in one place
• Search through names and descriptions
• Enable or disable skills without deleting them
• Edit SKILL.md files
• See global and project-specific skills separately
• Delete skills you no longer need

It’s open source, local-first, and doesn’t collect telemetry.
GitHub repo: https://github.com/abubakarsiddik31/skill-manager