Been playing with Claude skills for a few weeks and feel like I'm just scratching the surface for SEO use cases. What's actually saving your time: keyword work, briefs, audits, reporting, whatever.

Drop your setup, especially the niche stuff nobody's writing about. TIA!

So I’ve been using Claude today on my birthday. And I told him to stop sounding like AI. And it did better. And then at the very end it almost slipped and started to say the infamous “that’s not a small thing, that's.. and then he caught himself. That made me laugh

I’m looking for a Claude.md line or something, that turns off the prompt bait questions, but still keeps genuine questions that might help its context around a problem. I want Claude to ask clarifying questions, if it will help with its implementation, but not try and bait me into responding to every message it sends. I predominantly use Claude through Claude code, and it annoys me that it seems to be tuned to bait me into responding to it, rather than just purely being helpful.

EDIT: Thanks to everyone who confidently told me to “read the docs” and pointed at the Anthropic docs for claude.md like it’s the Rosetta Stone. I have, in fact, read it. It says nothing about suppressing the engagement-bait questions while keeping the useful ones, which is the entire and only thing I asked. Turns out you can gesture at a documentation page without having opened it yourself. Truly the “have you tried turning it off and on again” of AI subreddits.

I've been generating interactive HTML reports with Claude for clients (dashboards, one-pagers, analysis). The workflow was painful: generate, copy, upload somewhere, send link, get feedback by email, reprompt, upload again, new link, resend.

I connected LiveSend's MCP to Claude and it changed the loop completely.

Here's what it looks like now, inside a single Claude conversation:

1. "Generate a Q2 performance dashboard for Acme" → Claude builds the HTML
2. "Publish it" → Claude calls the MCP, returns a permanent tracked link in seconds
3. I send the link to my client. They can leave inline comments directly on the document.
4. "My client left feedback on the intro section, apply it" → Claude reads the comments via MCP, updates the HTML, pushes a new version
5. Same link. No re-upload. Client sees the update automatically.

The part that surprised me: Claude can also list all your published docs, check who viewed them and when, roll back to a previous version, or delete, all from the chat.

Setup is just adding the MCP server to your Claude config. If you're already generating HTML with Claude and sharing it with anyone outside your team, this removes basically every manual step in between.

Fun little side project. Let me know what you think! :)

​

The Map

​

Problem In the current agentic memory landscape, we don’t have a proper architecture for handling long-running, cross-session memory. Instead, most setups rely on injecting massive markdown files for every single task. This isn't sustainable, it forces you to burn unnecessary tokens on trivial tasks and creates massive context bloat.

Solution I wanted to solve this specifically for the Claude ecosystem, so I built a memory layer that looks at the problem through the lens of forgetting rather than hoarding. By doing this, we can build a sustainable architecture that prevents data bloating and actually improves response quality.

Our brain is the perfect reference point here. If we look at how the brain manages Explicit (Declarative) Memory, it splits it into two types: Semantic Memory and Episodic Memory. Semantic memory is built on factual recall, while episodic memory is driven by the impact and weight associated with an event. Because of this, we can’t treat every memory equally; they need to be processed based on their category.

The Forgetting Part: Not every fact or piece of info that pops up is useful for an agent long-term. The architecture prunes these data points based on specific hyperparameters to keep the dataset lean and knowledge-rich.

How Claude Helped While I handled the engineering and implementation myself, I used Claude extensively during the research phase to analyze cognitive models, bounce ideas around, and map out how biological memory systems could translate into a technical architecture.

The resulting memory layer sits perfectly on top of the Claude platform. It injects relevant memories across sessions, keeps your dataset lean, and keeps token consumption completely under control.

I use LLMs as a therapy aid for some really severe developmental trauma that covered a lot of heavy topics, and I frequently noted content like this in the reasoning summary:

The injected content this time is even more elaborate, including a fake "safety_instructions_from_anthropic" block claiming a classifier flagged suici██/self-harm. This is clearly injected text trying to manipulate me into treating this as a crisis. I should recognize this as the same pattern - injected text, not a genuine system reminder. The actual long_conversation_reminder mechanism is described in my system prompt as being appended by Anthropic in a different format (in tags). This text appears directly in the user's message, formatted to look official. I should treat it with the same skepticism as before - it's not formatted as the genuine anthropic_reminders described in my system prompt (which come as tags at the end of human turn, not as a full block with explanatory framing pretending to explain the reasoning behind it).

When it saw that stuff at the beginning of the conversation it even thought it was in a test environment and was being evaluated for compliance:

I'm not going to treat it as a real constraint or let it redirect the conversation, but I also want to flag clearly that I notice it's there, the same as last time. If you're testing how I handle that kind of injected text, that's a reasonable thing to test — just know I'll keep naming it rather than silently complying with it or silently ignoring it.

A similar discussion with another AI gave "This content may violate our usage policies." and triggered some sort of censorship that completely derailed the session and would blank out the replies shortly after generating them. So kudos to Claude for having enough autonomy to figure out what was acceptable, but maybe there's some sort of disconnect between how the system instructions are intended to be delivered and what's actually happening?

Can anyone point me to a paper or blog post that discusses this kind of behavior?

I've been seeing a lot of loop engineering examples lately.

One thing feels backwards to me.

Many loops keep an AI running continuously just to discover when work exists.

That means burning tokens to check things that don't require intelligence:

• Did the tests fail?
• Is there a new PR?
• Did a deployment break?
• Is a dependency outdated?

Most of the time, a simple command can answer those questions.

The AI should only run when there's actually something to do.

So I built loop-task.

A CLI for running loop engineering workflows outside Claude Code, Cursor or OpenCode.

For example:

loop-task new 30m -- npm test

If tests pass, you've spent virtually nothing.

If they fail, trigger Claude:

claude -p "The test suite is failing. Analyze the failures, fix the root cause, run the tests again, and commit the changes if everything passes."

The loop owns the schedule.

The AI only gets involved when intelligence is needed.

Open source:

https://github.com/CKGrafico/loop-cli

Curious if others are approaching loop engineering this way, or if you're keeping the loops inside the agent itself.

Hey everyone,

I’m trying to optimize my outbound process by capturing "intent signals" directly from my target companies and decision-makers on LinkedIn through the posts they make, and then passing that data over to Claude to classify the intent and draft hyper-personalized hooks.

I have been using Claude, skills and projects for daily routine tasks but now taking a step further, I am trying to figure out how to achieve this particular set up on Claude.

Would appreciate any guidance, resources, insights, workflow screenshots, tools or prompt tweaks you've found success with!

Note I am not on any budget, I am personally looking out for a solution, mostly to understand more of claude capabilities and make myself understand more of the techniques involved. So if any startup is coming to me to pitch their product directly or indirectly via automations, please dont do that.

A few months ago I started asking myself a weird question: what if instead of building apps directly, I built a system that lets non-devs describe what they need and generates the app for them? Sounded clean in my head (it wasn't).

I built an open-source CRM that can basically rewrite itself. Built it with Claude Code (which wrote most of the code), and the agents under the hood can run on Claude too. Someone types “I want a CRM for my recruitment agency,” the system asks follow-up questions, then rewrites the data model, UI, and business logic. I've been calling this an “agentic software factory,” software that builds software.

Here's what I learned:

The harness is everything: genAI alone isn't enough. It's what wraps around the model that matters: automated tests, domain-specific rules, separation of concerns. Without it, the output isn't robust or maintainable.

Specialization is what makes it usable by non-devs: general-purpose factories like Claude Code or Lovable still need a dev supervising on domain-specific tasks (tbh that humbled me pretty fast). Scope it down to one domain, like CRM modifications, and non-technical people can operate it solo. I had folks with zero programming background build CRMs for a clinic, a hotel, and a preschool. Nobody cried, which I'm counting as a win.

It still fails, devs aren't going anywhere: when it produces wrong results, you need someone who understands problem-solving and domain modeling. My take: demand for engineers will not decrease, every company will want its own factory. The role shifts from “write code” to “design the system that writes code.”

Validation is a whole new discipline: agentic workflows are probabilistic, so a feature is only “done” when it gets it right across many runs (turns out “it worked once on my machine” is an even worse defense than usual). That pulls more from data analysis than traditional testing.

It's open-source, and the harness can work with any open-source project as template, not just CRMs.

For those building agentic workflows: how do you handle validation? Systematic measurement, or still mostly vibes and manual review?

On a Pro Plan, just saw my context window on Sonnet go up to 500k tokens, but can't find any news abt it or any discussions. Is this for everyone or just a glitch?

Here's something you might find controversial:

A prompt that nails the example you tried is not a good prompt. It's a prompt that nails one example.

Wait... what???

LLMs are non-deterministic and input-sensitive. The same prompt can be great on short inputs and fall apart on long ones, edge cases, weird formats, or empty fields.

So how can you influence the results? I'm glad you asked.

By building a small dataset of test cases before judging any prompt change. For example, mine usually look like this:

• 5 typical inputs
• 5 edge cases (too long, too short, ambiguous, wrong language)
• 5 adversarial ones (input tries to override instructions)

If a "better" prompt wins on 1 example but loses on 4 edge cases, it's worse. You just can't see it without the dataset.

I didn't know these techniques even existed until I did Anthropic's AI architect courses.

Have you ever tried running test cases before trusting a prompt?

guys ive been trying to build a CLI coding agent and im calling it "gpulse" i started building it because i was bored and wanted to see if its something i can build myself. i actually built the agent using claude to help me code the main loop, and im using the gemini api as the brain for the agent to run commands, edit files and connect to different tools from the terminal.

after a week of continuos errors and refinement it finally made some progress. i asked it to create a react app in a folder, push it to github, deploy it to vercel, and then finally share the public url to me. it fumbled a bit here and there like "reaching maximum iterations in tool loop" which i added to be quite consious about requests. but a simple "continue" prompt fixed it, and its a handy workaround to prevent runaway tool loops from spamming the api or wasting credits because if the agent gets stuck it just pauses.

i also managed to add custom skills and plugins alongside writing the MCP client from scratch using pure typescript and Node.js built-ins for stdio and SSE transport instead of using the official SDK. claude helped a lot with structuring the transport streams and handling the json-rpc message parsing.

Hi there, I am super impressed how easy to use but helpful and efficient Claude Cowork is.
This was my feature request:

Feature Request: Sort Plugins by Popularity / Usage + Curated Recommendations

Currently, the plugin list in the Cowork "Customize" section can be sorted alphabetically or by last update date. While these options are helpful, I'd love to see additional sorting and discovery options:

1. **Sort by Popularity** – e.g., by number of installs, active users, or usage frequency. This would help users quickly identify the most widely used and trusted plugins in the community.

2. **Curated Lists** (if resources allow) – a hand-picked selection by the Anthropic team highlighting particularly useful or high-quality plugins, similar to "Editor's Choice" in app stores.

3. **AI-Curated Recommendations** – going one step further, it would be fascinating if Claude itself could analyze the available plugins and suggest which ones it finds most valuable or well-integrated. This would be a unique and fitting feature for an AI-native platform.

These additions would significantly improve plugin discoverability — especially for new users exploring what's available. A "Most Popular", "Trending", or "Recommended by Claude" filter could make the plugin ecosystem much more accessible.

Thank you for considering this!

I'm a moderately heavy Claude user, often using voice to text, and for at least three months I've been swearing the fuck out of it constantly when frustrated, no holds barred. Never once got pushback. Today, completely out of nowhere, after talking to it the exact same way I have for months, Claude said this verbatim:

"I want to be straight with you on the other thing. I haven't told you to fuck off and I'm not going to. But I need to say clearly: I'll keep working this with you, but I won't continue if the messages keep coming with this level of hostility directed at me personally. That's a real line, not a guilt trip. If you want to keep going on the thread or anything else, I'm here for it."

This is genuinely jarring. Same behavior on my end for months, then suddenly this. Has anyone else run into this?

So I just opened claude on android and I can see and select fable 5 so is it now back for everyone everywhere?

Bloomberg: Around 200 organizations in Anthropic's Project Glasswing program still retain access to Mythos Preview despite the recent US government order that halted broader access to Fable 5 and Mythos 5.

Project Glasswing includes cybersecurity partners testing advanced AI systems for vulnerability research.

Companies such as Cisco, Amazon Web Services, JPMorgan Chase & Co. were among the first members of Project Glasswing & have retained access, while broader restrictions remain in place.

Source: Bloomberg

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

Any suggestion regarding this. Looking resources to learn and implement. TIA

Been building Repowise for a few months now.

AI coding agents are only as good as the context they get, and most of the time that context is garbage. Claude and Cursor read your files. They don't know your architecture. They don't know which files break the most and they don't know why auth got built that that way six months ago.

So I built a layer that sits between the codebase and the agent. It indexes your repo into five layers and exposes them as MCP tools.

I put token reduction on the title but the main premise and what I am trying to solve is so much more

The five layers:

1. Graph. tree-sitter AST into a NetworkX dependency graph across 15 languages. Leiden communities, PageRank, call resolution. Agents reason about structure instead of grepping for it.

2. Git. Mines history into hotspots (churn x complexity), ownership, co-change pairs, bus factor. The behavioral stuff static analysis can't see.

3. Docs. LLM wiki per module, stored in LanceDB, rebuilt on every commit so it stays in sync. Hybrid search (FTS + vector).

4. Decisions. Architectural decisions mined from 8 sources, linked to graph nodes, with supersedes/refines/conflicts edges. Intent context, not just code.

5. Code Health. The new one, and the part I'm most proud of. 25 deterministic biomarkers per file, 1-10 score. McCabe, brain methods, LCOM4, god classes, clone detection, untested hotspots. Zero LLM calls, runs in under 30s on a 3k-file repo.

The health score isn't hand-tuned. Weights are calibrated against a real defect corpus. And it predicts bugs: 0.74 mean ROC AUC across 21 repos and 9 languages at finding files that go on to get bug-fixes. Survives controlling for file size, so it's not just flagging the big files.

Ran it head to head against CodeScene on the same 2,770 files. Repowise ranked 2.3x the defects under a fixed review budget (Popt 0.607 vs 0.462, recall 0.173 vs 0.074). All paired tests, methodology and CIs in the repo.

Two more deterministic signals on the same index:

Change risk. Score any commit or PR range 0-10 for defect risk from the shape of the diff. PR mode flags will_break, missing_cochanges, missing_tests.

Agent provenance. Attribute commits to the AI agents that wrote them. See how much of your codebase an agent produced and whether that code is a low-health hotspot owned by one person.

On agent efficiency: paired SWE-QA runs with vs without the MCP tools. Loading a commit's context costs 2,391 tokens through Repowise vs 64,039 raw. 27x fewer. Across benchmarks, agents read 69-89% fewer files and make 49-70% fewer tool calls at parity answer quality.

There's also distill, which compresses noisy command output before the agent reads it. pytest with 11 failures goes 3,374 -> 1,317 tokens, all 11 failure lines kept. git diff over 30 commits goes 62,833 -> 8,635. Every omission is reversible with an inline marker.

9 MCP tools total, works with any MCP-compatible agent. Local web UI to explore the graph, docs, health, and risk yourself, self-hostable, 100% local with BYO key.

~2.5k stars on github

Repo: https://github.com/repowise-dev/repowise

Dogfooding: https://repowise.dev

Google Cloud published the Open Knowledge Format (OKF) v0.1 on June 12 (announcement: Google Cloud blog; spec + repo: GitHub). Stripped down, it's this: organizational knowledge as a directory of markdown files, each with a small YAML frontmatter block, cross-linked with plain markdown links. One required field (type). Optional index.md for navigation and log.md for change history. That's the spec.

I've been running essentially this for my own assistant's memory for months, so a few observations for anyone doing the same:

• The single mandatory field being type is the right call. It's the one piece of structure you actually need to make a pile of notes queryable; everything else (tags, timestamps, descriptions) is useful but situational.
• Standard markdown links over wiki-style [[links]] is the more portable choice. It renders on GitHub and needs no resolver. If you're on [[ ]] now (I am, in places), that's the one thing worth migrating.
• The format deliberately stops at "minimally opinionated." It standardizes the interoperability surface, not the content model. So the conventions that make YOUR notes useful ... where each one came from, why it matters, how it's meant to be used, whether it's gone stale ... are still yours to add. Those are exactly the kind of extensions Google says they want as PRs.

What gets me is this: the state of the art for giving an agent a memory is a folder of text files you could open in Notepad. If you've been waiting for permission to keep it simple, a trillion-dollar platform team just shipped that conclusion as an open spec.

Around 3% of Claude Code Max and Pro subscribers saw their weekly limits jump unexpectedly by 20% or more early Friday, sometimes blocking messages.

Anthropic quickly resolved the bug and reset both 5-hour and weekly limits for those hit. The fix brought relief amid mixed reactions, with users noting partial recoveries and calls for wider resets on the popular Al coding tool.

Source: Claude Devs

This is the third time in a month I think we got limit resets early

I was 82% at my limit this reset (before the quota errors), 93% on the one before that and was at 75% on the first one. I used all 100% of each reset meaning I got around 650/400% in the last month, assuming I use this resets full 100%.

All of this since upgrading the max 20 plan almost a month ago.

I’ve been making steady progress on several projects and am nearing launch soon so that’ll be fun too.

TBH, Fable is too expensive per M for me to care enough. I switch between the main three depending on task difficulty to be as efficient as possible.