Sourcely

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

Sourcely AI

I made a Free and Open Source Next.js SaaS Boilerplate for Claude Code. Built with Next.js + Tailwind CSS + Shadcn UI. Features include Auth, Multi-tenancy & Team Support, Roles & Permissions, MFA, User Impersonation, Landing Page, I18n, DB, Logging, Testing. GitHub in the comments.

Hey everyone, I just open-sourced a Next.js SaaS Boilerplate built to pair with Claude Code. The idea: give Claude a well-structured, opinionated codebase to work from so you can ship a SaaS way faster than starting from scratch. **Stack:** Next.js + Tailwind CSS + Shadcn UI GitHub repository: [https://github.com/ixartz/SaaS-Boilerplate](https://github.com/ixartz/SaaS-Boilerplate) **What's included out of the box:** * Auth + MFA * Multi-tenancy & Team Support * Roles & Permissions * User Impersonation * Landing Page * I18n * Database * Logging * Testing I'm also totally open to feedback and suggestion.

This is insane.

Just installed an open source tool that wiped most of the tool-definition tokens out of my Claude Code context before any prompt. Same MCP servers. Same tools available. 8 servers, 142 tools across them. Before: the tool definitions ate 38k tokens of context every single turn. Cold start, my context bar was already orange and I hadn't typed anything. After: 4k. The Claude Code session sees three tools (`search_tools`, `invoke_tool`, `auth`) and dispatches everything else under the hood. When I ask for a thing, it ranks the catalog with BM25 in microseconds and surfaces the top 5. The part nobody's talking about: there's no LLM in the ranking loop. No embedding API to pay. No vector DB to host. It's keyword search over a flat projection of tool name + description, deterministic, offline. Apparently this was always going to be enough. It's [Ratel](https://github.com/ratel-ai/ratel). Open source. The install is `ratel mcp import` and it migrates your existing Claude Code MCP config in one command, with backups written automatically. Took me 90 seconds. Why is every "context layer" startup pitching me semantic embeddings and inference-time re-ranking when basic BM25 over tool definitions does this?

I’m not a developer. I’ve been using codebase memory MCP tools and Obsidian to give Claude persistent memory for my fantasy and sci fi worlds. Here’s what the dev-tool framing completely misses about creative use cases

Hi, I’m an accountant with very little coding experience (took 1 year of CS in college lol) so definitely can’t call myself a developer, but I’ve got a lot of worlds and characters in my head, the need to get them out in writing, and a Claude Pro sub I pulled the trigger on two months ago. I was hoping to see what I could do with things like Claude Code for more non-coding use-cases. So far it’s surpassed everything I’ve experienced except for one, major hang up: **LLM memory for long-context creative writing work still sucks.** Things like brainstorming for a fantasy universe or tracking the game state of a multi-session solo rpg campaign usually starts out pretty well for the first few chats, until you need to mount dozens of lore files and .md style guides to a project, have to wait for it to read all of that, then watch as your session usage bloats out for a simple reply and the quality degradation gets \*really\* noticeable. I’ve been lurking on AI writing subs and the sentiment seems to be shared across the board. So I looked in other places for possible solutions. Then I came across posts in this sub touting Claude memory MCP tools for codebases. Tools like Codesight and MemPalace caught my attention because I thought their applications could extend beyond coding and developer use-cases. The same semantic search and knowledge graph capabilities some of these tools offered for memorizing large, complicated codebases could be used to memorize large, complicated worldbuilding bibles as well, and most of the comments on these posts never mentioned that, or if they did, they were buried or ignored. I decided to test it out myself, starting with MemPalace, a suite of tools that work locally to index your Claude conversations and files into a semantic-searchable knowledge base it can query. My idea started out like this: since I’m already using Obsidian to organize my lore files (with an entry for each character, location, magic system, story arc, etc.) like a wiki or encyclopedia for my worlds, what if I had Claude save my Obsidian vault to its memory so it can recall those lore details whenever the context called for it in any given conversation? I was essentially making a “Second Brain” for Claude out of my Obsidian vault world bible, something I’ve read people doing already but never truly “got” it until I saw it in action. I had no idea about MCP tools before this but before long (and with Claude’s patient help) I was able to wire up the memory palace, mine my obsidian vault info into its memory (organized into verbatim chunks/snippets called “drawers”), and start chatting with it with its new “memories” at its disposal. I was surprised at how seamlessly it worked when I approached this tool sideways. I’d half expected it to work similar to how SillyTavern’s world info and lorebook injection worked, and in fact, I’d been thinking about using these tools to create a similar feature for my own Claude setup, but it was \*not\* like that at all. Lorebook injection worked by listening for a set of keywords that you set up in the World Info tab of SillyTavern, and when one of those keywords is detected in your prompt, it injects the entire lore file from World Info into the chat context. This can cause a lot of token bloat especially if your World Info entries are content-rich or you make a lot of lore references in your chat. What this did instead was make Claude ask plain-language questions to the MCP tools, things like, “What is Gene’s friendship with Felix like?” Or “what is Gene’s relationship to Clara-Belle?” When both of them are in a scene for example. It didn’t just look up Gene and Clara-Belle’s entire lore files and info-dumped everything into context, it pulled up the “Relationships” section of Gene’s file since that’s relevant to the context as well as Clara-Belle’s “Relationships” snippet from her file and any other relevant snippets, then pieced the full picture together through inference. The results: \~2% session usage on a cold start with Sonnet 4.6 with no project or additional context mounted. Claude references character motivations, relationship history, and world/location details I haven’t mentioned in weeks without me prompting it to. It picks up from where we last left off seamlessly across chat after chat. The reconstructive memory aspect I felt works like our own memory and produced perfect recall across sessions. Another side-effect I noticed is that when it references my lore files, it will pick up my style from the way the lore file is written. No more voice-flattening from encyclopedia-sounding lore entries. All the depth, nuance, and psychology I worked hard to cultivate are preserved and the Claude tools are smart enough to factor that in when it replies. I even make sure to add a “Voice” section to each character lore file in that character’s own voice so Claude can pick up on that when it reads that snippet in the tool call and applies it to its current context.

Keep seeing the AI solved math problems posts - genuinely curious about the relevance?

Keep seeing this news everywhere about how AI models solved some age old math problems ([source](https://news.geobrowser.io/story/6f59b5266dad4ce0ac0ba9487d372b71) article for context) It's definitely cool. But I'm trying to figure out what makes this is a headline moment? * Is solving 9/353 actually impressive, or is it impressive because any of them got solved by a system instead of a person? * "Few hundred dollars per problem" messaging. Is this something mathematicians care about, or is that just a number journalists latched onto because of the "AI is too resource heavy" narrative? I don't mean to downplay this or be ignorant in any way, just want to understand what it means for AI growth and what makes it apparently a milestone moment

AI is becoming epistemic infrastructure controlled by a handful of private individuals?

Most people treat AI as a convenient black box. Ask it something, it answers, you move on. But we’re sleepwalking into something bigger. I think Whoever controls the infrastructure of knowledge controls how people perceive reality. The Church held that position for centuries through controlling scripture. The printing press broke that monopoly by distributing interpretive power. AI is doing the opposite recentralizing it into a handful of corporations with no democratic accountability. “AI says X” is structurally identical to “studies show X” you’re invoking an authority you can’t directly access. Except with a study you can theoretically trace the source. With AI the chain is opaque by design. And it delivers wrong answers and right answers with identical confidence. There’s no texture to signal doubt. AI isn’t neutral, it’s being heavily calibrated. In the west, the models are trained to be more “ethical” maybe more liberal and always try to give you a more “balance” take on things. Chinese AI simply doesn’t allow you to access to anything that put the CCP is a bad light. The more you rely on AI in domains where you lack expertise, the less capable you become of evaluating whether to trust it. AI works best for people who already know enough to catch its errors the opposite of how most people use it. Imagine the next generation of people growing up and being shaped by these AI. I can’t help but feel nervous and scared for the future. OpenAI said 10% of our entire population has already started using chatgpt. Regardless of the accuracy of this number, I feel like we are slowly entering into a mass hallucination / blind reliance on these AI models. We’re not just offloading cognitive effort. We’re handing the dial over who shapes how billions of people understand reality to a small group of unelected, largely unregulated private individuals.

I think most company brains are just creating a second source of truth

I keep running into this when using Claude with company context: the “company brain” layer sounds useful, but I’m not sure it actually solves the real problem We already have tasks in Linear, docs in Notion, customer notes in Attio and Granola, random decisions buried in Slack, and half the real context sitting in people’s heads My instinct was that adding a shared memory layer on top would help Claude understand everything better But the more I think about it, the more it feels like we're just creating another place that needs to stay in sync If the Linear task says one thing, the Notion doc says another, Attio has newer customer context, and the actual decision happened in Slack, I don’t really know what I would want Claude to trust. And if Claude is answering from a summary of all of that, I don't think I've solved the problem I’m not saying shared memory is useless. I actually think it’s probably one of the most important parts of making Claude useful inside our company over the coming weeks. I just struggle with the idea that the memory can be separate from the work itself It feels like the tasks, docs, decisions, customer notes, and ownership need to become the brain itself, it does not make sense to me to keep these two separate Otherwise I worry I’m just giving Claude a second version of reality that slowly goes stale Curious how other people are handling this

I went from 1 to 10 apps on the App Store in 4 months - vibe coding as a senior iOS dev

I code for 20 years and make mobile apps for 15+. This February I decided to try vibe coding, but at scale. Back then, I had 1 app in AppStore. Now I have 10. These 4 months were intense, and many lessons were learned. 6 guidelines surfaced, here they are, in no particular order: * **use 2 models, one as workhorse, and the other as the verifier / backup.** Sometimes I hit my Claude limit midday, which is frustrating, so I got a MiniMax 2.7 subscription too. I reckon any other decent model will do it. Claude Code does the main stuff, backup does boilerplate, fixing, review. * **optimize at the root.** I spent A LOT more time writing specs than interacting with the model. Around app number four, I stitched together a genesis prompt template, that I started to use going forward. It has 23 sections, I open sourced it (link at the end) and it contains everything from monetization to design system. * **keep your mental mode light.** This was an unexpected bottleneck: switching back and forth between 3-4 apps at the same time (that was my upper limit) is taxing. I had to make serious changes to how I work. I literally struggled to keep my focus. * **expand verification, because build shrinking.** As a senior dev, I used to spend the best part of my work writing code. Now no more, Claude Code does it for me, BUT I have to double down on verification. I check especially after bug fixing and at the beginning of every app generation, to make sure the structure, file names, variables, etc. are in order. * **marketing starts as early as building.** Before February, the main question driving my work was: "is the app done yet?" Now it's: "does anyone know about the app yet?" I started promotion, marketing as soon as the first lines of code were generated. Still learning my way around here, but it's starting to work. * **treat every app as an experiment.** This one was a bit hard to swallow, because I'm used to the old, inertial way of doing things: bet on an app, push it and do whatever it takes, because of the sunken cost fallacy (I worked so hard to build this). Now the building is approaching zero, so pivoting / iterating is cheaper too. If you're vibe coding for a living, or at scale, I'd love to hear your comments on these. P.S. If you're curious about the 10 apps and the technical challenges I faced with each of them, as well as about the genesis prompt template, they are here, in a [longer post](https://dragosroua.com/vibe-coding-for-senior-ios-developers-guidelines-after-10-apps-in-4-months/). (It's a mix of productivity, books, utilities and fitness apps)

I open-sourced the skill I use to run parallel AI coding agents with a human gate before production

I've been using Claude Code to ship features in parallel. Three agents working at the same time, each in its own git worktree so they don't step on each other. That part works great and there are already good tools for it. What I couldn't find was the part that comes after. How do you merge all that work, validate it together, smoke test it, and make sure nothing hits production without you saying so? So I built a skill definition that handles the full pipeline: parallel workers, an integration branch, type/build validation, runtime smoke tests, staging promotion, and a hard human gate before main. Every feature gets a --no-ff merge so you can revert one feature without touching the others. It's not a library or a package. It's a markdown file you give to your LLM and ask it to adapt to your stack. Works with Claude Code, Codex, Cursor, whatever reads markdown. The repo: [https://github.com/knods-io/parallel-agents-skill](https://github.com/knods-io/parallel-agents-skill) To install it, paste this to your LLM: "Read the SKILL.md file from https://github.com/knods-io/parallel-agents-skill and adapt it to our project. Keep the core flow and the mythological worker names, but tailor everything to how we actually work. Then install it as a skill in this project." I'd genuinely appreciate feedback. What's missing? What would break in your setup? What would you change?

Spec: Version Control for AI Agent Intent

AI agents are getting good at writing code. That is not the hard problem anymore. The hard problem is coordination. When you have multiple agents working on the same codebase, who decides what gets built? How do two agents with conflicting opinions resolve a disagreement? How does a human stay in control without reviewing every line before it gets written? Git does not solve this. Git is brilliant at tracking what changed, when, and by whom. But it operates on code that has already been written. By the time a conflict shows up in Git, two agents have already done the work, made assumptions, and written implementations that may be fundamentally incompatible — not at the line level, but at the intent level. I wanted to solve the problem one layer up. Before the code. The Core Idea Every code file in a Spec project has a paired .spec file living right next to it. app/Http/Controllers/HomeController.php app/Http/Controllers/HomeController.php.spec The .spec file is a plain Markdown description of what the code file is supposed to do. It is the source of truth for intent. Agents do not write code directly — they write proposals against the spec. The code only gets written once every agent has explicitly agreed on what it should do. The spec is never “checked out.” It has one canonical state at any moment. Agents read it, propose changes to it, and debate those proposals. When all agents agree, the session locks, the spec is updated, and only then does an implementer generate the code. Code is always the output of consensus. Never the battleground. The Flow A typical session looks like this: An agent reads the current spec and submits a proposal with reasoning attached. Not just what they want to change, but why. A second agent reads the proposal and responds — accepting it, rejecting it with specific objections, or suggesting modifications. If they get stuck, a mediator surfaces the contradiction and helps them find common ground. The mediator has no vote and no authority — it just asks better questions. When every agent has explicitly agreed on the same spec state, the session locks. An implementer reads the locked spec and writes the code. One pass. From a fully agreed specification. This means a few things that feel unusual at first: A build is never produced from a broken or partial spec. If agents cannot agree, nothing gets built. That is a feature, not a bug — better to surface the disagreement at the intent level than to discover it six files deep in an implementation. Conflicts in Spec are semantic, not syntactic. Two agents can touch completely different parts of a spec and still be contradictory. One says the controller should cache responses for 60 seconds. The other says it should always fetch fresh data. No line conflict. Completely incompatible intent. Spec is designed to catch this before a line of code is written. Every message carries reasoning. Proposals alone are not enough. The full session log — with reasoning trails — is what keeps the human comfortable staying hands-off. The Human Role The human operates at what I call a god level. You provide the original request. You can observe at any granularity — project, session, agent, or individual message. You can intervene at any point: rewrite the spec, stop a session, override an agent, shut the whole thing down. And critically, every intervention you make becomes a lesson — captured with full provenance and fed back into future sessions so the system learns from it. The goal is not to remove the human from the loop. It is to move the human up the stack. Mission commander, not task manager. You set the intent. The agents work out the details. You intervene when they get it wrong, and the system gets smarter from each intervention. The Technical Details Spec is built in Rust. Three dependencies: serde, serde_json, and tokio. LLM calls go over raw HTTP via curl — no SDKs. The provider layer is deliberately abstract. Agents, the mediator, and the implementer all talk to the same interface. Swap the provider in config and nothing else changes. Different agents can run on different models. You can run fully local with Ollama for cost control or privacy. Agent identity is explicit. You set SPEC_AGENT_ID before running commands. Without it, Spec errors with a clear message. This is intentional — the system cannot coordinate identity automatically, and a silent fallback to hostname:pid would make consensus unreachable in practice. The lesson graph lives at: ~/.spec/lessons.json It lives outside the repo entirely. Lessons accumulate across all projects and branches. Check out an old branch and you do not lose what the system has learned. Lessons are knowledge about how your agents work, not knowledge about any particular codebase. A hook system lets you plug in your own behavior at defined lifecycle points: • post-agree: fires when a session locks • post-build: fires after code is written • pre-release: fires be

If you've ever wondered how rigorous data analysis+social science research can look with AI, I've finally launched a nice website for my open-source Claude Code researcher's toolkit: the Data Analyst Augmentation Framework! Equal parts interactive explainer on agentic orchestration + free tool

If you've ever wondered how rigorous data analysis+social science research can look with AI, I've finally launched a nice website for my open-source Claude Code researcher's toolkit: the Data Analyst Augmentation Framework! Equal parts interactive explainer on agentic orchestration + free tool

Some obsidian + Claude code

I'm trying to get a massive novel (\~2800 chapters) and all the systems in it inside a new TTRPG system and even though it by definition is not a usual case for Claude code but it is the only good way to do it... Atp I have made 1/3 of it being 4.3mb of pure text in 2.5 weeks. The reason why I'm posting being... I don't know if there's really better way to do what I do than just 6 steps thing 1- I do a full canon dump myself from every single trustable source, add some notes etc. 2- Opus reads and interprets it with a prompt "Strictly follow the canon" 3- He creates a structured by a template that we (myself & opus) created for the thing we're doing at the moment 4- He checks for any hallucinations that don't follow the canon and fixes them 5- He checks yet again, this time — for readability and grammar (this is crucial because I write it in a different language than English) 6- I myself reread the final version myself, redacting minor inconsistencies and mistakes. Is there any kinda way to optimize it and not get worse quality?

If you've ever wondered how rigorous data analysis+social science research can look with AI, I've finally launched a nice website for my open-source Claude Code researcher's toolkit: the Data Analyst Augmentation Framework! Equal parts interactive explainer on agentic orchestration + free tool

If you've ever wondered how rigorous data analysis+social science research can look with AI, I've finally launched a nice website for my open-source Claude Code researcher's toolkit: the Data Analyst Augmentation Framework! Equal parts interactive explainer on agentic orchestration + free tool

Building Conifer, an open-source local inference runtime (free + open source)

Team of 5 from Princeton, and we got funding to build a local inference engine for Apple Silicon - rust, hand written kernels - and we're at the point where working with \~100 people will expose bugs/what people want tool-wise. All of this is free open source - will remain so. We're ahead of llama/mlx for small models working on similar performance for larger in the long run. Where this is going: the engine we're building supports a fully local agent that can do real work on your own files, apps, has permissions with OS kernel enforcement. Asking for any feedback and if you're really interested we're opening up a waitlist and taking 100 people into free beta and working with them 1-on-1 to writing specific tools and performance engineering on setups (sign up at [https://conifer.build/feedback](https://conifer.build/feedback)). Please only do this if you imagine using this and have some idea in mind, we'll release a full version later this summer but we want to build around talent. We need real usage and unrestrained feedback from ppl who run local models. site is live at[ conifer.build](http://conifer.build/). also drop anything you want to see or ideas. [conifer.build/feedback](http://conifer.build/feedback) if you want to drop comment anon

I checked which of my Claude Code skills actually fire. Half never had, and they were burning 23k tokens every session.

I've got a pile of skills installed in Claude Code and I started wondering how many actually auto-activate vs. just sit there loading their instructions into context every session. Turns out Claude Code's session logs (`~/.claude/projects/*.jsonl`) already record this. Both when a skill gets explicitly invoked, and a per-message "attribution" tag showing which skill was active. So you can reconstruct, per skill: how often it fired, how much it was actually used afterward, when it last activated, and what it costs in context tokens. I pulled mine and it wasn't pretty. About 4 skills doing real work, about 13 that have never fired once, together loading 23.5k tokens into every single session for nothing. So I built a small CLI/MCP tool to make this a one-liner instead of grepping JSONL by hand: $ skillvitals scan | skill | fires | engaged | ctx | last seen | status | |------------------|-------|---------|------|-----------|-------------| | frontend-design | 31 | 140 | 6.4k | today | healthy | | ab-test-coach | 2 | 2 | 5.7k | 3d ago | misfiring | | data-analysis | 0 | 0 | 4.2k | never | never-fired | | ... | | | | | | 3 dormant/never-fired skills are costing you 8.7k tokens per session. It also flags why a skill might not be firing (vague description, no "use when..." trigger phrasing, near-duplicate of another skill, broken frontmatter) and suggests fixes. It shows them, it doesn't edit your files. A few honest notes: * It's 100% local. Only reads files already on your machine, no uploads, no telemetry. * The health labels (dormant/misfiring) are heuristics, not ground truth. The thresholds are in the source if you want to argue with them. * It does not generate activation hooks. That space already has good tools (skills-hook, claude-skills-supercharged). This is just the monitoring layer. Install: pip install skillvitals # or: uvx skillvitals scan Repo: [https://github.com/PraveenKumarSridhar/skillvitals](https://github.com/PraveenKumarSridhar/skillvitals) Genuinely curious what everyone else's dead-token number is. Drop it in the comments if you run it, and I'll take feature requests or bug reports here or on GitHub.

We built a managed memory API for AI agents (open-source SDK + AGM-style belief revision for handling contradictions)

Hey all! We just launched a managed memory API for conversational AI, letting developers add long-term memory to their agents with a single HTTP call. It's built on our in-house xmem SDK, which automatically extracts facts, episodes, and artifacts from multi-turn conversations and handles contradictions and updates through an AGM-style belief revision mechanism. When a user changes a preference or corrects an earlier statement, old memories get automatically flagged as "superseded" instead of piling up as noise. At query time, you can also walk the supersede chain to trace the full version history of any memory. Under the hood, PostgreSQL + pgvector (with HNSW indexing) delivers millisecond-level semantic retrieval, Redis handles multi-pod session caching, and the system natively supports multi-tenant isolation with data separation at the user and org level. For developers, this means you no longer have to stand up your own vector store, design dedup logic, or babysit session state. Hand off the memory layer to us and focus on what your agent actually does. Feel free to try it out, it's free to start. Please let us know your thoughts on how we can improve or features to add! [https://github.com/XTraceAI/memory-sdk-ts](https://github.com/XTraceAI/memory-sdk-ts) [https://docs.mem.xtrace.ai/introduction](https://docs.mem.xtrace.ai/introduction)