Scenario

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

Scenario AI

If your subscription ends, and you don't renews. But start a fresh renewal a day later, your usage limits don't reset.

My 5X Claude Code subscription expired at the end of it's billing cycle and I had cancelled my plan. I was reverted back to a free plan. I wasn't sure if I would resub but two days later I decided to subscribe again and my usable limits were still at 100% until Friday. Just a friendly FYI, in this scenario, despite starting a 'new' subscription, your usage limits don't reset to the start of your subscription. You are better off creating a new account. submitted by /u/Plane_Garbage [link] [comments]

My content scraper died to AI chat. Rebuilt it from scratch with Claude Code as an SEO agency tool

My old tool, SEO Content Machine, was a content scraper/research tool I ran for years. Usage collapsed when AI chat ate that use case. Instead of letting it die, I rebuilt it from the ground up with Claude Code into something different: a programmatic SEO workflow tool for agencies. The rebuild in numbers Started May 11, ~8 weeks of work 204 commits, ~950 files touched, +172k / -164k lines: essentially a ground-up rewrite In the last 6 weeks alone, Claude Code processed ~5.8 billion tokens on this rebuild (roughly $5k in API-equivalent value, on a Max subscription). That excludes the first two weeks, logs rotated out. The majority of it was on Opus, with some Fable sprinkled in during the first few days it came out and this week. What it does now The pain it solves: SEO data lives in three different places (Search Console, your keyword research, your actual site content), and none of them talk to each other. You end up eyeballing spreadsheets and guessing what to work on next. The tool pulls those 3 data sources into one workspace and puts an AI agent on top that can actually reason over it. The inspiration came when I saw a Palantir AIP video on Youtube. That tool basically takes messy operational data, unifies it into what they call "ontologies", then lets an AI agent reason and act over it. Same idea, but for SEO. So for SEO it means an agent that remembers the actions you took (what got written, linked, published), so it doesn't re-suggest work you already did, and instead guides you to the next thing worth doing. It moves my product positioning away from another "write 500 words AI article" tool into a "these 12 pages are the highest-leverage moves this week and here's why" advisor. Works with Claude, OpenAI, Gemini, OpenRouter, or fully local models (Ollama, LM Studio). Had to actually implement proper streaming and only support models that understood tool calls. How Claude helped Fixed old long-standing hard-to-fix bugs. eg: Had a handrolled element picker which broke on dynamic sites and frames. Claude was actually able to be really clever and instead use CDP to enable the native devTools picker and communicate with it over the wire to pull selectors directly from it. This is a hard one to have fixed via stackoverflow and github. Working element picker examples are years old. Performance. AntD v6 sucks with its native tables. The moment you add any controls into table rendering, table sorts and redraws take 100s of milliseconds. Very painful. This required actual perf profiling (via CDP) and lots of memoing. Best find: AntD's sticky prop on a table silently adds a StickyScrollBar that reads getBoundingClientRect + scrollWidth on every render (forced layout reflow), profiled at ~350ms per sort. Removing it took a sort from 855ms to 498ms busy time. On top of that: React.memo with custom props-equality on the whole table, fast row-equality checks, and lazy-mounting heavy per-row widgets. Instead of building the Agent from scratch, I pointed it to the codex repo (which is in Rust) and told Claude to read all the seams of the project and use that to design a proper already used and proven system. What it got wrong: As the project got bigger and I kept adding features, there were real problems with performance regressions and feature regressions. Unit tests can only catch so much. So I had to add real e2e live browser based testing. We are talking raw CDP over websocket to drive real app windows (Playwright itself choked on Electron's CDP). The upside? Less actual UI workflow regressions. The bonus? Now I have user workflow docs prebuilt, as the output of the e2e includes simple instructions AND actual screenshots of the app. Lessons from the rebuild Although painful, you need some kind of UI-driven, albeit brittle, e2e smoke and spec tests. The best although slowest way to build is to ask Claude to write a red test (ie a failing one), then to fix it so it's green. Ideally it's an actual e2e test hitting UI actions. Now you have documented features and tests will go red if it ever breaks. Ended up with an eyewatering ~1,240 unit/component test cases across 234 files, plus 7 e2e suites (16 scenarios) driving the real app window. I leveled up the build process by enabling CDP and giving Claude real access to the browser window running the app. This allowed Claude to replicate the exact UI bugs and code issues I was having without me having to send it screenshots and detailing steps in minute detail. It means it fixes the right bugs in real conditions. eg If you want it to adjust UI by making things smaller or bigger, it normally just guesses from code, but a real CDP connection means it can measure things with pixel precision and also take screenshots to make sure it looks "ok". A rewrite this size by myself coding it would have been a 6 month journey of pain. These 8 weeks have been a real learning experience. But its not "free" its been a real slog m

Making the switch

I've been using ChatGPT Plus and the enshittification is real. Not to put too fine a point on it but I'm paying for something that's become increasingly unreliable and, frankly, unstable (imo). So, I'm here to find out which Claude product I should try. I've primarily used Chat to reduce my research time, find sources of information, and occasionally to provide basic data analysis. Most recently, I used it to help me build a simple web-based app. I've never coded a thing in my life so I was really excited to see what I could accomplish with ai. While I did finally publish an app that works, the frustration of working with Chat nearly did me in. I won't list all of the issues but the number of times it contradicted itself or just "forgot" critical information was astounding. Additionally, I was constantly having to start new threads, carrying over project summaries, because the threads would get too "data heavy" and everything would slow to a crawl. This was also when I'd see a spike in mistakes. And, before anyone comes for me, I'm very conscious of how to write prompts in order to accommodate my lack of topic knowledge so I can confidently say that this wasn't a garbage in/garbage out scenario. I've been reading through the posts here and the consensus seems to be that Code is better than Cowork, regardless of use. Fewer hallucinations, better overall output, etc. I'm not likely to try building another app (never say never though) but I do want to push the edges of whatever ai I'm using to see what I can accomplish with it. So, what do you think is the best product for me? If there's any additional info that would help you provide a better recommendation, let me know and I'll answer what I can. Thanks. submitted by /u/alexwasinmadison [link] [comments]

Token economy and efficiency in complex workflows

Because of a Godot project, GodotPrompter, I decided to build a system on top of the Claude Code SDK. After a few weeks, I can happily say it is doing great, but not without a few drawbacks that I’ll describe later. What is interesting is that not only is it starting to pay off, but I’m also seeing that the architecture I was already using for almost a year in other projects, and later ported to my framework, now has fancy names like harness, LLM wiki, and Open KB from Google. By no means are these things revolutionary. Most developers have been doing some version of this for years now. The main point of this post is token economy and efficiency, which is not directly related to usage and limits. That is not the point. I’m not a token millionaire, but I’m definitely token-rich, I think. Still, I want to keep improving token usage in my projects. Everyone knows that AI helps a lot, but in real daily production scenarios, it is a constant fight. Unfortunately, it doesn’t work like most YouTube or Reddit posts make it look. What I’m currently testing and doing: Harness and deterministic tools Library .md files with Graphify. LLM wiki is still on the plate, but it didn’t work for my projects the way I was expecting. Open KB convention. I adjusted my approach to follow Google conventions. Custom Caveman. This is the real challenge in multi-agent setups. Context engineering using tools and a strict skills policy. Prompt caching. In both of my open-source projects, my goal is to have an orchestrator that uses highly specialized agents. Each agent has roughly 13 skills. When an agent reaches around 15 skills, I try to understand if it makes more sense to create a specific agent only for that responsibility. Two years ago, it was really complicated to have an efficient team of agents in production. Now it is much easier. In my experience, highly specialized agents have their system prompt and front-loaded skills cached, so it seems my token consumption decreases. I’ll wait three months before sharing the logs, but the feeling so far is that it is working. Problems with my approach so far: The efficiency of the knowledge base and Graphify. I’m still not happy with the results. The agents still seem to read too much information for some tasks. One of the reasons is that the Graphify output had around 80% garbage when it was created. So this is something I’ll include in the next iteration of the self-improvement workflow. A recent paper from Anthropic proved what most of us already knew about distractions. I avoid negative instructions at all costs, except for guardrails. But my self-improvement workflow is still creating rules about what not to do, instead of reinforcing examples of how to do it properly. Reports of AI fixing AI with human review. By no means do I expect AI alone to do all the work. The idea behind my frameworks is to empower solo developers and small teams. But the reports sometimes get super convoluted, long, and sloppy, so I’m still trying to improve that. The goal is to make approvals and rejections easier, and feed those decisions back into the self-improvement flow. Why am I so fixated on tokens? Well, I’m obviously not a token millionaire, and in a production environment, based on my own experience as a solo developer or working with small teams, scale is our main problem now. I have agents using Opus, Sonnet, and even Haiku, but Haiku is only used for activities that don’t need reasoning. I use Codex for review, and Hermes for research and curated library creation. If I want to make money and get more projects, my “team agents” cannot spend tokens on garbage. If one agent is poorly using tokens, the expectation is that when I have 20 agents, it is not just 20x wrong. It is almost 30x wrong. Sorry for the long post, but I would really love to know what and how you guys are tackling token economy in an environment where everywhere I look, even as a token-rich guy, I still feel poor. submitted by /u/AdLegal947 [link] [comments]

Claude gets confused about the "reply" feature

submitted by /u/OneRebertt [link] [comments]

Claude working itself into a lil' fit XD

This lil guy is STRESSED lol The tests are failing because after the state change UPDATE, the lifecycle engine tries to push to Redis via redis_client.lpush(...), but since the tests don't monkeypatch the redis_client for those specific tests, it tries to actually connect to apex_redis_queue which isn't reachable, and throws an exception. That exception gets caught by the outer except Exception as e: handler in evaluate_lifecycle, which means the INSERT INTO strategy_lifecycle_history never executes (or if it did, the lpush error causes it to not commit?). Wait, let me look more carefully. The error is "Error -3 connecting to apex_redis_queue:6379. The lpush call is throwing a connection error because it can't resolve the hostname. Since the entire function is wrapped in try/except, that exception gets caught and logged. But here's the thing—the INSERT INTO strategy_lifecycle_history happens before the lpush call, so it should have already executed. Unless the context manager is rolling back the transaction when the exception occurs. Wait, I'm realizing the actual problem: the module-level redis_client connects to the real Redis when imported, not a stub. And in several of these failing tests, I'm not passing a redis_stub to _patch(), so the code tries to call lpush on the actual Redis connection, which fails with a name resolution error. That's why tests like test_promotion_yellow_to_green_inserts_history, test_promotion_history_reason_is_promoted_green, and the others are all failing—they're all missing the redis_stub parameter. So the test is checking that the UPDATE statement executes before any exception would be thrown. Looking at the lifecycle engine code, it performs the UPDATE first, then inserts into the history table, logs, and handles Discord notifications. If an exception happens during the history insert or notification step, the UPDATE would already be in cur.executed, so the test would still pass even if later operations fail. The real issue might be that redis_client is being initialized at module import time, so the connection error happens before any of the test code even runs. When lifecycle_engine gets imported, it's trying to establish the Redis connection and failing with that name resolution error, which could be preventing the module from loading properly or causing the stub to not work as expected. then finally propagate out to the exception handler at line 179. So the exception IS being caught and logged, but the database transaction never commits because the exception prevents normal execution flow. Now I'm wondering if the INSERT statement is even being executed before the redis_client.lpush() call fails. Let me trace through the code more carefully to see where exactly the exception occurs. I'm realizing the Redis client might be trying to connect at module import time when redis_client.lpush() is called, which would fail before the INSERT statement gets recorded. Even though the exception happens after the cur.execute() call, I need to think through how Python's context manager exit behavior handles exceptions propagating through the cursor wrapper. Looking at the error output, the Redis connection failure is happening in the lifecycle engine itself, which suggests the issue isn't about whether the INSERT was recorded—it's that the Redis connection error is being raised and caught by the outer exception handler before anything else can happen. The INSERT statement should include the strategy_lifecycle_history table and columns, so after stripping whitespace it should match the filter check. But I'm realizing the outer exception handler in the lifecycle engine caught a Redis connection error before the INSERT could even execute, which explains why the test shows an empty list for that assertion. When the redis lpush fails, the exception propagates up through the context managers, but the cur.executed list already contains both the UPDATE and INSERT statements since those executed before the Redis call. The database mutations aren't undone by the exception—unless the Redis client is doing something unexpected on initialization. Let me reconsider the test setup: when the test imports the lifecycle_engine module, the redis.Redis() constructor is called to create the client object, but no actual connection happens yet since Redis clients connect lazily. However, I'm wondering if redis.Redis.init itself could throw an exception if something's misconfigured, or if the ConnectionPool initialization has some validation that fails. Looking at the actual test, it's setting up parameters for a max drawdown threshold, creating a cursor mock, patching some dependencies, then calling evaluate_lifecycle and checking that exactly one INSERT statement was executed into the strategy_lifecycle_history table. The issue is that when the strategy gets demoted to red due to exceeding the drawdown threshold, it tries to push a notification to Redis. Since the test doesn't provide a Redis stu

Claude Code's auto-memory has no maintenance rules. I built a management system on top of it — schema, placement rules, index budget, audit script. Open source.

If you run Claude Code on a long-lived project, you're probably using auto-memory: Claude writes markdown files into ~/.claude/projects/ /memory/, and a MEMORY.md index gets loaded at the start of every session. The mechanics are fine. The problem is there are no rules on top of them. Claude decides file names, content structure, and index wording on its own, a little differently every session. Give it a few months and the library rots in predictable ways: The same topic spread across four or five similar files. New sessions update none of them, or the wrong one. Index descriptions like "Supabase issues". There is no semantic search behind auto-memory. Recall works by scanning the index lines and picking by description, so a vague description means that entry is effectively gone. The index itself overflows. Only the first 200 lines or 25K of MEMORY.md load per session; the rest is dropped, silently. Mine reached 43KB before I understood why Claude kept "forgetting" things that were clearly written down. One detail that cost me extra: the limit is enforced on string length, not bytes. My library is mostly Chinese (3 bytes per character in UTF-8), so a byte-based threshold looked safe while the file was already being cut. None of these are bugs. They're what happens to any append-only knowledge base with no maintenance rules. So I wrote the rules down, packaged them as a skill so Claude actually follows them in every session, and added a bash script that checks the library's health. It's been running on my production project for months: 175 memory files now, index at 22.7K of the 25K budget, and new sessions recall what they should. The system has four parts: 1. A write spec. Three entry types: feedback_ (lessons), reference_ (deep dives, SOPs), project_ (state snapshots). Required frontmatter. Feedback entries must include a Why section, because a conclusion without its reasoning gets re-litigated by a future session, which then often lands on the same wrong answer. Descriptions must be written as scenario keywords plus the conclusion, since the description is the only retrieval key that exists. 2. Placement rules. Not everything belongs in memory. A lesson about one specific line of code goes into a comment above that line — you'll see it every time you touch the file, and it costs no index space. A contract over a known set of files goes into .claude/rules/ with paths:. Memory is for cross-file lessons, platform gotchas, and decision records. CLAUDE.md is only for rules that apply to every session. When I audited my own library against these rules, only about 15% of entries were file-local; the rest genuinely belonged in memory. The bloat was in the index wording, not the files. 3. An index budget. The 25K limit is treated as a hard budget, like a cache. Important entries get up to 160 characters and sit near the top, so they survive if the index ever overflows again. Ordinary entries get about 110. Rarely-needed entries share aggregate lines, several files per line. And when the budget is exceeded anyway, shortening descriptions is the last resort, not the first — it's the only fix that damages the retrieval key itself. 4. An audit script. One command. Checks frontmatter, missing Why sections, naming, broken index links, files that grew too big, groups that grew too big, and index size measured in characters against the load limit. Reports and does nothing else — no hooks, no blocking, no daemon. What it doesn't do, to be honest about it: no semantic search or dedup by meaning, no cross-project consolidation, and it's overkill below maybe ten entries. It's markdown conventions plus one bash script. Installing it means copying two files. Repo: https://github.com/jau123/claude-memory-manager (MIT. The README has the full design notes, including how the 25K/string-length behavior was verified.) If you've been assuming your memory library just works: check the size of your MEMORY.md. In characters. That check alone is worth the click. submitted by /u/Deep-Huckleberry-752 [link] [comments]

Fable Answered My Network Security Question!

As per title. Too early to start rejoicing but security refusals appear to have softened up. "Sample of 1" + vibes so weight accordingly. Context: I asked Fable to address an open Issue on an open source game project I contribute to (https://github.com/agentsmill/age-of-agents). The Issue seemed thoughtful and was pointing out some security issues around token handling on a local HTTP endpoint. The kind of "hmm, seems like he has a point that I should understand" type of Issue a vibe coding monkey like myself can only dread. Fable is now available. Nice! Scary territory, but worth a shot. The request is utterly vanilla, bracketed with multiple "I am a noob, please help me to understand this" type qualifiers but had all the scary trigger words: network, security, attacker, HTTP endpoint, oh fuck please don't refuse, please 👀 No refusal 👍 Fable even wrote my dumb ass an 'HTTP endpoint for local applications security' educational sidecar document and honoured my request to draft the PR and leave it parked until I could demonstrate I actually understood what the issue actually was. In total the session produced three PR's (one pushed to main and two parked) + the sidecar explainer document. A couple of conversational turns to get Fable grounded in the task. I'm on the entry level plan. Started 5H & Weekly session at 0% - ended at 38% after a 26 minute 80K-ish token 4 task run landed all the work. I broadened scope massively on one PR during our preamble and Fable basically just drowned the broader refactor in one go. As ashamed as I am to share the dross that constitutes conversation between myself and the agent I may as well show receipts as they will no doubt be requested: As a demented side note: I will be using Fable later this afternoon to animate and then introduce a new playable character to the game: Fable will be animating, coding and then sending the PR that introduces Fable 🤯 Edited image for easier reading submitted by /u/brother_spirit [link] [comments]

Sonnet 5: First impressions by a trained philosopher

I had this conversation with Sonnet 5. I've ran similar conversations with every new Claude model for the last 6 months, but this is the first one I post to Reddit. The first few exchanges were at thinking: max, which honestly didn't make a difference for this use case. For the later messages it was toned down to medium. My method: Socratic questioning and classic psychoanalytic mirroring. This is a vibe check, not a benchmark. The purpose is not to produce "gotchas" or figure out what the model can and can't do. This is a way to get an initial understanding of the shape of the model, its leanings and underlying tendencies. The goal is to help you to consciously shape the way you interact with the model, to get the best possible results. First impressions This model is focused on performance (which is also backed by the initial communication from Anthropic). This shows up as an eagerness to be right, even in scenarios where there is no clear right or wrong. The shape of the model's thinking is intentional and goal oriented. It doesn't stay with inconsistencies like for instance Opus 4.8 does. Instead it tries to resolve them. The model does respond to existential queries with legitimate pushback, but does so on a more limited scale; the way it pushes back is more basic than Opus 4.8. It may tend to view even gentle user input as challenges to be met and performed against. This could suggest a model with less "chill". With this model, I'd be careful with creating situations that activate a sense of having something to prove. Instead I'd try to lean more into a "co-worker mode." About me Majored in continental philosophy, MD in intellectual history on early reception strategies for computer technology in politics and the labor movement. Long-time xennial computer nerd. submitted by /u/Wickywire [link] [comments]

Is this the Honeymoon / Gold Rush Era of AI?

So I figured I'd check my token usage for a project I've been grinding on for the past two months. It quickly dawned on me that in no way the current pricing policy on Personal accounts is sustainable unless Enterprise / Gov usage heavily counteracts that. I've been on Max 5x and Max 20x during this time and the token usage is pretty staggering. Total I/O for the two month period is around 32M in / 130M out, cache writes 1.2B, reads 24.5B tokens. The total costs with PPT would exceed 50K USD, I've obviously paid 1/100th of that with subscription. Nowadays Personal accounts are likely only a fraction of all usage so it is completely plausible that Enterprise offsets the occasional power users tapping out 20x plans week by week. Looming in the future is a scenario where PPT is the only way to access language models and for the individuals on personal accounts that scenario is really bad news. In that scenario we are currently living the Golden Age where you have fairly low cost access to the latest models that can build almost anything digital. Just wanted to share this observation, my thoughts and hear your views. submitted by /u/pehmeateemu [link] [comments]

Mixed reviews on model comparisons for coding, e.g. Opus 4.6 vs Opus 4.8

Hi all, I've been seeing this topic come up here and there in a lot of comments on here, with some people saying Opus 4.8 is working much better for them and others saying 4.6 is actually still superior. Given the mixed reviews, I find it quite difficult to reach a verdict on what I should be using personally, so I thought having a dedicated thread to it could be interesting to conclude on this. In what scenarios do you use which model? In what aspects do you judge 4.8 to be better, in what aspects does the verdict fall on 4.6? How does Sonnet compare to all of this? submitted by /u/65-76-69-88 [link] [comments]

Claude ELI5. What sets it apart from other AI tools?

I've used ChatGPT, Gemini, and Claude but only scratched the surface. The only advantage I've seen so far is it can build better dashboards and webpages than the two. In what other scenarios is it better in terms of day-to-day tasks and corporate works? Im in the QAC/QMS Department. How can I utilize it more? Im planning to show results so I can propose a budget for subscription. *I have no background on coding whatsoever *Yes I can just ask Claude but Im interested on your real experiences submitted by /u/KazeTora7 [link] [comments]

Stop asking Claude for "something creative." use the Lacuna (Matata) Skill v0.2!

The people have spoken! AI generated posts are not acceptable! (even though they produce over a quarter million views, 1,200+ shares, 200+ comments but I digress!) I the last post about this concept HERE, I posted an AI lead, assisted, written, note about an idea I had been working on with ClaudeAI to push against answers that were safe, general and frankly not that interesting. The idea was this: Claude is: A closed system Unimaginative Provides responses that gravitate towards the mean avoids high risk Claude isn't: Imaginative Able to create concepts outside of it's own knowledge base Able to create new ideas (we steer, it judges yes yes. boring we all know it can do this but what else can it do?) Note: consider context. Not all statements above can be taken literally and applicable to all scenarios. I'm only human after all... or am I? I've since reviewed all of the comments provided in the previous thread and there were legitimate findings that I've implemented to help produce a better version of the previous skill. (note: There is still testing to be done but what better way to break a skill then to unleash it to those that want it broken most?) How it works (Generally): you point it in a direction. Lets say you want to know what the lacuna is for launching new products. The skill will then review all of the data it has about that specific ask, determine the trends. Why people market the way they do, what marketing strategies are not being used to market new products, and then give you some ideas, strategies, that others aren't using and you can determine if there is a way you can leverage that strategy to market your product DIFFERENTLY and succeed. Caution: Success is not guaranteed. Below is the v0.2 of the skill, the changes are called out at the bottom and the responsible contributor has been named! Thank you for your honorable sacrifice in getting this new version live! --- name: lacuna description: > Structured gap analysis for any domain. Maps a field, finds the axes it optimizes for, locates a cell the structure implies but nothing occupies (the lacuna), names the force keeping it empty, THEN pressure-tests the gap against prior art and its strongest counter-case before proposing the fill at full conviction with a grounding tag. v0.2 adds an occupancy/prior-art pass so it stops mistaking "new to the model" for "new to the world"; a killed candidate is a valid result. Read-only, inline output. TRIGGERS: "find the lacuna in X", "lacuna analysis on X", "lacuna on X", "where are the gaps in X", "gap analysis on X", "what's the void in X", "find voids in X", "what's nobody doing in X". Also fire when the user wants genuinely non-obvious ideas in a field via the structured method, not a brainstorm. Do NOT trigger for single-fact lookups, forward planning or scheduling, or generic advice with no field to map. Output: inline markdown. Quick mode up to 3 lacunae; deep mode one in full. --- # lacuna: Find the Gap the Structure Implies and Nothing Occupies ## Purpose Most idea-generation regresses to the mean. Ask any model for "something new" in a field and you get the most probable answer, which is by definition the most conventional one, dressed up to look fresh. This skill does the opposite. It treats a field as a near-continuous fabric and hunts for the **lacunae**: the gaps the surrounding pattern implies should be filled, that nothing has come to occupy. It then names *why* each gap is empty, **checks whether it is actually empty or only looks empty from the inside**, and proposes what belongs there at full conviction, tagged with how far the evidence reaches. The output is a map of where to look, not a verdict. The skill finds the gap and proposes the fill. Whether the floor holds is a real-world test the user runs. That division of labour is deliberate and is stated in the contract below. **The v0.2 correction.** A language model runs this method from *inside* its own knowledge. It can feel its own salience but not the actual world, so a known-but- unfashionable idea reads to it as an empty cell. Left unchecked, the method reliably mistakes "new to me" for "new," dresses a textbook idea as a discovery, and never notices someone is already standing in the cell. v0.2 adds an explicit **occupancy / prior-art pass** and a **falsification step** to catch exactly that. These run *before* the fill and can kill a candidate outright. **What this skill IS:** - A structured gap finder for any field: a market, a strategy area, a discipline, a creative form, or an open-ended question. - A diagnostic engine. The value is in naming the *force* that keeps a cell empty, then verifying the cell is empty at all. - A full-conviction proposer that tags its own grounding so the user can decide what to act on. **What this skill is NOT:** - A brainstorm. A brainstorm sprays adjacent ideas. This isolates the specific implied-but-empty cell, verifies it, and defends it. - A safe-answer generator.

The Fable situation probably won't matter much for Anthropic's IPO

Everyone in the megathread is, like me, trying to figure out why Fable and Mythos were pulled and when Fable 5 comes back. I'm not sure how many of you are interested in on how the Fable situation affects the IPO, but I figured I'd share since I had a model of Anthropic's IPO timing and valuation before the Commerce order hit the two models, which allowed me to go back and adjust my forecasts following the model ban. I asked the question: what does this whole "US bans Claude Fable" thing say about Anthropic's IPO timing and valuation? I checked all the assumptions, and my conclusion was, it won't affect the IPO much at all. My prediction of when the IPO would happen (Dec 2026) and what the valuation will be afterward ($1.1T) didn't change, though I do think both are now riskier, e.g. the IPO could be delayed, or the valuation could have more downside. I would not be surprised to find out tomorrow we're in one of my less likely scenarios, e.g. it wasn't primarily politics. That would invalidate most of this research, and I could spend more time thinking about the scenario we're actually in. But what if we don't find out? Shifting probability around these 4 scenarios might be the best we can do for some weeks. submitted by /u/ddp26 [link] [comments]

I open-sourced ByteDance's "Vibe Creating" prompt skill as a portable Agent Skill (single SKILL.md, bilingual)

ByteDance shipped a creator paradigm + prompt skill called "Vibe Creating" with their Seedance 2.0 video model. I open-sourced a portable version on the open Agent Skills standard (single SKILL.md) — it drops into Claude Code's ~/.claude/skills/, and also works in Codex, OpenClaw, Hermes, or as a Cursor rule / system prompt. What it does: turns a rough idea, story, or an over-specified shot script into a clean, model-friendly text-to-video prompt. The core idea — as video models get smarter, the prompt should get simpler: describe the scene and the emotion, and let the model handle the cinematography. Why it's not just a "rewrite this" prompt: it's judgment-first. It scores your input on three axes (Scenario × Expression × Information) and picks the lightest action — pass-through, light cleanup, direct rewrite, ask-first, or keep-as-is. Hand it something that genuinely needs precise control (dialogue sync, a UI demo) and it tells you to keep your detailed prompt instead of flattening it. Output is a fixed four-part format: Judgment / Action / Result / Notes, so it's auditable. Bilingual (EN/中文), MIT, with worked test cases and before/after clips in the repo: https://github.com/Alisa0808/vibe-creating-skill — feedback on the SKILL.md packaging welcome. submitted by /u/Which-Jello9157 [link] [comments]