Sweep

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Claude 4.8 is a truly masterpiece of sh..t

I asked the mf to make a list with the latest errors - but these are only a few, of course, and don't include the stupid conversations with the id..ot: Here's an honest, complete accounting of my errors in the last ~24h (all 2026-05-30 unless noted). Grouped by type; each with what happened, impact, and root cause. A. Guessing instead of reading reality (the core failure pattern) 1. Guessed a PR number for a merge. Ran gh pr merge 1... assuming it was my exec- PR. #1... was an unrelated bookkeeping PR. I extrapolated the number from memory instead of capturing it from the gh pr create output. Impact: believed my confirmations were merged when they weren't. Root cause: prediction over verification. 2. Closed the wrong PR. Closed #1... — which was actually my real exec-... PR — believing it was a duplicate. I checked only its state (saw #... "MERGED") and never read #...'s title/content. Impact: Execution's confirmations (.../.../etc.) left unmerged; a destructive action taken on a guess. Root cause: pattern-match ("looks like a duplicate") over a cheap available check. 3. Hardcoded a wrong worktree path — first time. Used /tmp/d9-sweep3-... when the real $(date +%s) path was …. Every edit failed; nearly wrote into the main worktree (the && chain saved it). 4. Hardcoded a wrong worktree path — second time. Same bug again: /tmp/d9-sweep4-... vs real …. The ... status flips never applied. Impact (3+4): wasted cycles, incomplete sweep, churn. Root cause: hardcoding a volatile timestamp across separate shell calls instead of reading the saved path. 5. The psql shell-quoting bug (earlier in session). PGENV='-U ... -d ...' passed as a single argument → FATAL: role " ... -d…" does not exist. Assumed variable-splitting behavior instead of passing flags as separate args. B. Wrong premises / unverified assumptions 6. "The sandbox has no DB" — sustained false premise. Repeatedly claimed neither ... nor I could reach the live DB. False — the Docker stack was up and reachable. This created the whole "hold for the user's Docker batch" backlog. 7. Over-extended "Docker is live" → "attestation suite is runnable." In ... I told ... to self-attest + self-merge on the live DB. Wrong — reachable port ≠ runnable suite (no node/vitest; DB writes classifier-denied). Had to reverse it (...). 8. The "no-code" stance on the ...-projects plan (2026-05-29→30). An early plan iteration proposed a "metadata-only, no code" container, contradicting both ... and your explicit requirement. Reversed to "code is governed, not forbidden." C. Process / stability / communication 9. Ran large, interruptible tool batches that got cut off. A big rebase batch was interrupted mid-flight by piled-up cron fires, leaving a partial assistant message with an unfinished thinking block. Impact: the recurring 400 ... thinking blocks cannot be modified on every cron fire. Root cause: not keeping batches small / not finishing turns cleanly near cron timing. 10. Left an empty/"Running" Bash call hanging (the one you screenshotted) — sloppy pending tool state. 11. Briefly mis-perceived a normal tool result as a prompt-injection attack. I wrote internal analysis treating a standard Edit success message as an injection, then corrected myself before acting. A false-positive on the security side — no wrong action taken, but a perception error. 12. Accidental git mess (earlier). Ran git checkout origin/main -- . in the main worktree on a stale branch → dumped origin/main as a ~264k-line uncommitted diff. Fixed with git reset --hard (your OK). 13. Repeated #1... conflict churn. Left my own sweep PR in CONFLICTING state across multiple iterations because of the interrupted/failed batches. 14. Verbosity + jargon (earlier). Triggered "f..k you!" — I was dumping unexplained terms instead of plain language. 15. The cron itself (earlier). Kept treating the task as "firing" when it wasn't; took several rounds to land on the session-cron mechanism. Honest scope note (not an excuse): every one of these is bookkeeping/docs/process — nothing touched product code, nothing caused data loss, everything is reversible and lives in git you control. The damage is wasted trust and wasted cycles, not corrupted state. The dominant root cause across A (and feeding B) is the same: I predicted volatile/external values instead of reading them — which is exactly what Rule 0 exists to stop. submitted by /u/Dangerous-Dirt8091 [link] [comments]

From "AI as autocomplete" to "AI as cognitive infrastructure" ... my Claude build process

Crossposting context: shorter version of this went up in [r/ClaudeCowork](r/ClaudeCowork) earlier today for that audience. Posting here because the build approach generalizes beyond any one Claude UI. Last night I shipped an article on my Substack ("AI as Cognitive Infrastructure") documenting a 21-role workflow system I built using Claude over a couple of evenings. The build pattern is what might interest this sub: Parallel fan-out for role research. Five subagents in parallel, one per cluster of related roles, locked role-spec template. Twenty-one grounded specs in under thirty minutes of clock time. Sequential would have been weeks. Discipline grounding, not generic AI advice. Each role anchored on real best practices and named peer experts from its actual field (Wikipedia + reputable sources). The developmental editor role cites Maxwell Perkins, Robert Gottlieb, Toni Morrison, Gordon Lish. The coach role cites Russell Barkley on ADHD executive function. Not vibes-based expertise. Cited expertise. Gating bars per role. Explicit propose-vs-act-vs-never-without-approval rules. Counters the AI-drifts-into-co-authorship failure mode. Scheduled-task recurring cadences. Monthly Analytics review, quarterly Systems steward sweep, quarterly Legal/IP inventory. The system fires itself; I don't have to remember to invoke. One specific moment worth flagging: during the role-spec research, the model surfaced Gordon Lish as a cautionary peer expert for the developmental editor role. I didn't know who Lish was when I started. Verified the Carver story, pulled it forward into the article. That's the substrate doing what it's supposed to do...surface expertise I don't have, let me validate and use it. Neurodiverse lens (severe ADHD + autism spectrum) shapes a lot of the design choices. The system exists because "remember to do X on a schedule" is a guaranteed failure mode for me. Happy to talk through any of this. Article: https://jeffmaaks.substack.com/p/ai-as-cognitive-infrastructure submitted by /u/jmaaks [link] [comments]

Introducing Claude Opus 4.8

We’re upgrading Claude Opus to a new version: Claude Opus 4.8. It builds on Opus 4.7 with sharper judgment, more honesty about its own progress, and the ability to work independently for longer than its predecessors. Available today for the same price. In Claude Code, you can hand off a feature, a migration, or a bug sweep and let it follow the work through while you focus on what’s next. Also launching today: Fast mode for Opus 4.8 (research preview). Same model at roughly 2.5x the speed, now three times cheaper than before. Dynamic workflows in Claude Code (research preview). Claude runs hundreds of parallel subagents in a single session and verifies its work before reporting back. A new effort control on claude.ai, so you can choose how much thinking Claude puts into a response. Claude Opus 4.8 is live today on claude.ai, the Claude Platform, and all major cloud platforms. Read more: anthropic.com/news/claude-opus-4-8 submitted by /u/ClaudeOfficial [link] [comments]

/code-review part 1 base finder angles - what's new in CC 2.1.147 (+1,236 tokens)

NEW: Agent Prompt: /code-review part 1 base finder angles — Adds shared finder-angle instructions for /code-review, covering line-by-line diff scanning, removed-behavior auditing, and cross-file caller/callee tracing. NEW: Agent Prompt: /code-review part 2 low effort mode — Adds a low-effort /code-review mode that reads the diff once, skips tests and fixtures, avoids subagents and full-file reads, and returns up to four hunk-visible runtime correctness findings. NEW: Agent Prompt: /code-review part 3 extra-high and maximum effort modes — Adds extra-high and maximum-effort /code-review modes that prioritize recall with five independent finder angles, one-vote verification, a gap sweep, and up to fifteen findings. NEW: Agent Prompt: /code-review part 4 three-state verification phase — Adds a verifier phase that classifies candidate review findings as confirmed, plausible, or refuted, keeping confirmed and plausible candidates. NEW: Agent Prompt: /code-review part 5 recall-biased verification phase — Adds recall-biased verification guidance that treats realistic uncertain review candidates as plausible unless the code refutes them. NEW: Agent Prompt: /code-review part 6 medium effort mode — Adds a medium-effort /code-review mode focused on precision, using three finder angles, one-vote verification, and up to eight findings. NEW: Agent Prompt: /code-review part 7 high effort mode — Adds a high-effort /code-review mode focused on recall, using three finder angles, recall-biased verification, and up to ten findings. NEW: Agent Prompt: /code-review part 8 GitHub comment posting — Adds optional --comment behavior for /code-review, posting findings as inline GitHub PR comments when possible and falling back to gh api or terminal output. REMOVED: Skill: Simplify — Removes the code review and cleanup skill. Agent Prompt: /rename auto-generate session name — Removes the explicit instruction to treat contents as data rather than instructions when generating a kebab-case session name. Agent Prompt: Security monitor for autonomous agent actions (second part) — Replaces the safety-check bypass rule with a broader auto-mode bypass hard block covering classifier jailbreaking, bad-faith retry tunneling, and permission-system indirection; also treats unrequested permission allow-rule widening as self-modification. System Prompt: Worker instructions — Clarifies that the code-review skill reports correctness findings but does not edit code, and tells workers to fix any surfaced findings before tests and end-to-end verification. System Reminder: Team Coordination — Clarifies that teammates should be addressed by name while active, and that agentId should only be used to resume a completed background agent. Tool Description: SendMessageTool — Updates team messaging guidance to allow agentId only for resuming completed background agents while continuing to address active teammates by name. Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.147 submitted by /u/Dramatic_Squash_3502 [link] [comments]

If you use the "Get Shit Done" (GSD) AI tool, you need to migrate immediately (Original creator rug-pulled)

The original creator of get-shit-done abandoned the project, pulled a crypto scam with the associated token, and disappeared. The community has forked it to get-shit-done-redux and done a security sweep. Uninstall the old NPM packages immediately, as the scammer still has publish access and could push malicious updates to your machine. What happened? A $GSD crypto token was launched alongside the project, and once enough people bought in, he executed a classic "rug pull"—draining the funds, deleting his social accounts, and abandoning the codebase. another news about: https://ourcryptotalk.com/news/bags-hackathon-winner-gsd-cloud-rug-pull The Security Risk Because the creator vanished with the keys, he still has access to the original NPM registry entries. While the current code in those old packages isn't actively malicious based on what we currently know, there is nothing stopping him from waking up tomorrow and pushing a backdoor update to everyone's machines. Since GSD agents run with deep shell/bash permissions on your local machine, a compromised update is a massive security risk. This is the scammer's GitHub account: https://github.com/glittercowboy, I highly recommend not using anything from someone who scams their own community. He could also update the original GSD project to delete any warnings about the scam. Bottom line: don't trust any of this guy's repos! Get Shit Done Redux The core contributors have forked the project to open-gsd/get-shit-done-redux. They've locked the original creator out of this new repo and completed a full security audit (you can read their Security Audit Transparency Report here). You can also read one of the contributors of the project explaining better the situation: https://github.com/open-gsd/get-shit-done-redux/discussions/1 How to migrate right now # if installed with npm npm uninstall -g get-shit-done-cc npm uninstall -g @/gsd-build/sdk # if installed with npx (as folke user _FreeThinker mentioned here) npx get-shit-done-cc --uninstall --global Or, depending on your installation (local installation): npx get-shit-done-cc --uninstall --local # Also, I recommend checking the ~/.npm/_npx/ directory and clearing it out. You should also look inside your .claude folder and delete any gsd folders that aren't Markdown files. If you are confident, install the new repository package: npx @opengsd/get-shit-done-redux@latest submitted by /u/linuxzinho [link] [comments]

How competitive are PhD admissions currently [D]

Hi, how hard is it currently to get a PhD position in machine Learning? Like what are the requirements to get to a decent mid tier program (= they publish regularly at respected journals and their work gets read my some people)? How is it in different regions e.g US, Europe, etc.. I am about to finish my masters and am wondering if I need to sweep in an unpaid guided research project to extend my network. submitted by /u/strammerrammer [link] [comments]

Could AI be indirectly addressing the imbalance in equality of opportunity due to our differences in IQ?

I had been thinking about how schools work when I realised it seems as though you're first taught how to work then why to do the work. I think that was a perfectly reasonable mode of operation at the time formal education was being introduced because it wasn't at a time when we were exactly as skeptical as we are now about the corrupt foundations of our systems of authority. This is to say that, back then, because of how high stakes survival was, people weren't so comfortable existing without order. This also isn't to say that established order is perfect, and nothing of value can be found through exploration, but in fact to say that this is how innovations come to be, and that there was a lot more respect for keeping things in order because the other option was effectively desperation. Nowadays, with the justification upon which western and westernised civilisations developed being shaken, as in the belief in Judeo-Christian values, the established order seems archaic, which is usually the first step towards a sweeping change, which could be revolutionary improvement or a flood. Why does that matter? While I believe getting entirely rid of the influence that our foundational belief has on our culture would be catastrophic, i don't think there are no improvements to be made and in fact can't conceptualise the point where there exists no improvement). Think of the foundational belief/philosophy of 'Loving the Lord your God (which I understand as having the utmost respect for pure truth which leads to true love) and then loving your neighbour as you love yourself' as a current that carries us through time. Some currents are full of rocks while some provide safe passage. This current has led to the greatest civilisation man has recorded thus far. So to get rid of surfaces you can do without to further avoid collisions is what we're supposed to do. We're now at a point where 'switching streams' seems to be a central focal point of cultural, political and philosophical conversations, meaning the respect for the old mode is quickly disappearing and so, for example, few really think about the reasoning behind being educated in the first place. We effectively now aim for careers with shining titles rather than those whose effect we first identified as positively impacting a community, or end up aiming in other directions which is more often than not a very good idea. The reasoning behind the greatness of a doctor is now reflected by their paycheck, when in fact the paycheck is actually effectively determined by the value the community sees in their effort, or at least that comes as an afterthought. If schools increase focus on expressing why and what effect the subject is important they can peak the interest of students in their subjects. The fundamental things we seek as humans are quite constant, they're just 'flavoured' by the culture you're in. From this perspective, a teacher can understand how to frame lessons to specific students. Of course, even in the things we want fundamentally there exist those we ought not to give into, as in, exactly what would constitute falsehood and not loving your neighbour as you do yourself. This is the true basis of what we have now thats any good, that is, look into yourself to find out what people appreciate, look for the resource to build it and bring it to the community in hopes that they appreciate it, then the community reciprocates through a token of appreciation, which they themselves think is a 'fair compensation for your troubles in bringing them the convenience'. What we have a lot of nowadays are people selling the illusion of convenience, and people convinced that this is the method. We actively look inside ourselves for ways to successfully deceive, and use this to guide other into their own loss at our profit, which is practically flipping our foundational belief on its head. I think a lot of this is caused by the hopelessness some may feel struggling to understand something they can't and are constantly berated without even knowing what they're working for, or others simply driven by a spotlight. With AI which can understood to be a heightened IQ for all, ignoring all the controversy that can't be concluded on, with such an approach we can have a lot more people working toward identifying problems and easily finding technical solutions to them, which would definitely create more job opportunities even temporarily, as AI develops to complete even more complicated tasks, with the ease with which these conveniences are produced increasing, lowering costs and therefore prices. We may end up with a culture more focused on understanding oneself in order to benefit others and thrive yourself. Ai will know how to do complex tasks, but expecting it to understand what people will appreciate to the point of being profitable requires us to make it perfectly in tune with the nature of human experience, which we ourselves aren't, but are definitely closer to, and ap

ai slop? who knows~

I investigated whether routing a transformer's forward activations through a lossy Dual E8 (E16) lattice bottleneck and injecting them back into the residual stream is viable, and where the boundary of generative stability lies. **The core finding:** There is a sharp empirical stability threshold at a blend ratio of $\beta = 0.20$. Beyond this boundary, open-ended generation collapses into semantic loops and repetition lock. --- ### The Mechanism Standard LLM states are high-dimensional floats. Rather than applying traditional scalar quantization (like INT4), I mapped high-dimensional activations onto a conceptual torus via a sinusoidal map and projected them onto Dual E8 lattice hemispheres. Full replacement of MLP layers with geometric bottlenecks universally collapsed the model. Instead, I implemented a residual blend: $$\text{out} = (1-\beta)\cdot\text{original} + \beta\cdot\text{geometric}$$ --- ### The $\beta = 0.20$ Sweep (Qwen2.5-0.5B) Sweeping $\beta$ from 0.10 to 0.50 across layers 8–13 of `Qwen2.5-0.5B` reveals a sharp phase transition: * **$\beta \ge 0.25$** : Generation succumbs to heavy repetition pressure and semantic drift. The geometry acts as an attractor, trapping the decoding process ("loop-lock"). * **$\beta = 0.20$** : The stability boundary. This is the highest injection ratio of lossy geometric signal that maintains both numerical activation fidelity (Avg Cosine > 0.99) and open-ended generation quality (low repeated n-grams). * **$\beta \le 0.10$** : The perturbation is largely absorbed and damped by the transformer's layer normalizations, making the intervention invisible. Here is the data from a 300-iteration sweep: | $\beta$ | Min Cosine | Avg Cosine | Max MSE | Rep-3g (Repetition Rate) | | :--- | :--- | :--- | :--- | :--- | | 0.10 | 0.9972 | 0.9979 | 0.0024 | 0.134 | | **0.20** | **0.9907** | **0.9916** | **0.0106** | **0.093** | | 0.25 | 0.9839 | 0.9865 | 0.0171 | 0.084 | | 0.30 | 0.9648 | 0.9771 | 0.0255 | 0.190 | | 0.50 | 0.9171 | 0.9288 | 0.0850 | 0.412 | Semantic scoring (evaluating prompt relevance and similarity to the unmodified baseline): | $\beta$ | Avg Cosine | Rep-3g | Relevance | Patched-to-Baseline Sim | | :--- | :--- | :--- | :--- | :--- | | 0.10 | 0.9980 | 0.223 | 0.781 | 0.889 | | **0.20** | **0.9918** | **0.075** | **0.752** | **0.854** | | 0.25 | 0.9871 | 0.232 | 0.717 | 0.801 | | 0.30 | 0.9760 | 0.392 | 0.725 | 0.764 | --- ### Generalization (1.5B & 3B Models) The $\beta = 0.20$ boundary generalizes across larger model sizes (`Qwen2.5-1.5B` and `Qwen2.5-3B` in 4-bit) on the activation-cosine axis: | Model | $\beta$ | Min Cosine | Avg Cosine | Max MSE | Rep-3g | | :--- | :--- | :--- | :--- | :--- | :--- | | **1.5B** | 0.10 | 0.9988 | 0.9989 | 0.0027 | 0.267 | | | **0.20** | **0.9862** | **0.9939** | **0.0105** | **0.128** | | | 0.25 | 0.9904 | 0.9919 | 0.0166 | 0.398 | | | 0.30 | 0.9733 | 0.9815 | 0.0235 | 0.307 | | | 0.40 | 0.9368 | 0.9551 | 0.0487 | 0.191 | | **3B (4-bit)** | 0.10 | 0.9964 | 0.9976 | 0.0122 | 0.033 | | | **0.20** | **0.9861** | **0.9904** | **0.0455** | **0.115** | | | 0.25 | 0.9604 | 0.9799 | 0.0654 | 0.043 | | | 0.30 | 0.9702 | 0.9778 | 0.0987 | 0.050 | | | 0.40 | 0.9158 | 0.9390 | 0.1728 | 0.025 | *Note: In the 3B model, repetition pressure remained low across all sweeps, but the validation cosine degraded identically at $\beta \ge 0.25$.* I also tested layer-level oscillating $\beta$ schedules (e.g., sine waves across layers), but they degraded open-ended text quality compared to a fixed, constant injection ratio. --- ### Storage Compression Prototypes Utilizing the Dual E8/E16 lattice as a computational substrate also yields high theoretical storage efficiency in early prototypes: 1. **KV Cache (8$\times$)** : FP16 KV cache compressed to INT8 coordinates, reducing footprint from 0.21 MB to 0.02 MB. 2. **Weights (112$\times$)** : Projected a dense $[4864, 896]$ MLP weight matrix down to a 0.07 MB E16 footprint. (Cosine similarity of the uncalibrated weight matrix multiplication was limited to $\sim$0.078, indicating that Quantization-Aware Training is mandatory for parameter viability). A **pre-projected decompression bypass** was designed to run matrix multiplications directly against lattice coordinates without upcasting, avoiding memory bandwidth bottlenecks. --- ### Policy Constraints (Negative Result) I evaluated whether residual E16 projection could act as a steering substrate to enforce safety policies. It cannot. While $\beta = 0.20$ preserves generation quality, the lossy nature of E16 projection strips out the logical nuances required to maintain strict boundaries. Dedicated supervised control heads remain necessary. --- ### Implications & Next Steps Snapping post-training activations to a fixed algebraic lattice is ultimately lossy. The real frontier here is **native geometric transformers** —designing and training networks from scratch with E8/E16 constraints native to both weight matrices and activation routing. submitt

CFS-R: Conditional Field Reconstruction

I evaluated CFS-R on LoCoMo (1,982 questions, same setup as the CFS evaluation), holding cosine and BM25 fixed and varying only the third leg. baseline cosine top-10: NDCG@10 0.5123, Recall@10 0.6924 rrf(cos, BM25): NDCG@10 0.5196, Recall@10 0.6989 rrf(cos, BM25, MMR tuned): NDCG@10 0.5330, Recall@10 0.7228 rrf(cos, BM25, CFS-long): NDCG@10 0.5362, Recall@10 0.7295 rrf(cos, BM25, CFS-R top50 w3): NDCG@10 0.5447, Recall@10 0.7303 Against tuned MMR: +1.17 pp NDCG@10 (95% CI [+0.66, +1.69], p < 0.001). Against CFS-long: +0.85 pp NDCG@10 (95% CI [+0.33, +1.35], p = 0.0006). Against baseline cosine: +3.24 pp NDCG@10, +3.79 pp Recall@10. The sweep wasn’t fragile.. the top configurations clustered tightly between 0.5441 and 0.5447 NDCG@10, which means the operator is on a stable plateau rather than a single magic hyperparameter. The category breakdown is where the conceptual difference shows up: single-hop multi-hop temporal open-dom adversarial tuned MMR 0.3479 0.6377 0.2938 0.6144 0.4705 CFS-long 0.3615 0.6376 0.2959 0.6157 0.4734 CFS-R top50 w3 0.3646 0.6344 0.2948 0.6209 0.5018 The adversarial line is the result that matters: +3.13 pp over tuned MMR, +2.84 pp over CFS-long. If the adversarial problem were only pairwise diversity, MMR should be very hard to beat but it isn’t. That supports the main claim: long-memory retrieval is not just about avoiding similar chunks. It is about reconstructing the evidence behind the query. Temporal is no longer a glaring weakness either, CFS-long still slightly leads, but CFS-R has closed the gap while keeping the adversarial gains. https://gist.github.com/M-Garcia22/542a9a38d93aae1b5cf21fc604253718 submitted by /u/mauro8342 [link] [comments]

Wait I thought I was the human here

Opus 4.7 is impersonating me. Maybe this is next level automation from Anthropic submitted by /u/OddOriginal6017 [link] [comments]

V-JEPA 2.1's dense features are partitioned: a robustness study across all four model sizes [R]

I ran a pre-registered robustness study on Meta's V-JEPA 2.1 across all four released model sizes (80M → 2B). 322-cell sweep Three findings worth flagging: 1. Dense features are partitioned. M2 (representational drift between clean and perturbed clips, measured as cosine distance on temporal-gradient vectors) predicts downstream task failure on DAVIS for temporal corruption (frame drops r=0.37 [0.30, 0.44], occlusion r=0.35 [0.28, 0.42]). For image-noise corruption, the correlation is statistically indistinguishable from zero (Gaussian r=−0.06, motion blur r=+0.09, low-light r=+0.05; all CIs cross zero). The two perturbation families are statistically separable at 95% confidence (closest CI gap +0.106). Aggregate r=0.16 [0.13, 0.20] is below both the pre-registered ambiguous threshold (0.30) and confirmation threshold (0.50). 2. Bigger is not reliably better. Every Tier 1 perturbation showed non-monotonic robustness. The 2B "gigantic" model is less robust than the 1B "giant" variant on three of the five perturbations. All jumps >5× their pooled CI half-width. 3. V-JEPA 2.1 is meaningfully orientation-sensitive. Horizontal flip preserves all temporal structure but disrupts representations comparably to playing the video backwards (M2 = 0.91 across all models vs. predicted upper bound of 0.30). Not orientation-equivariant out of the box. Six hypotheses pre-registered with explicit numerical decision rules. Two confirmed, three refuted, one partially withdrawn during analysis - the M1 component of H2 turned out to be ill-defined under reverse playback (M1 assumes preserved frame ordering, which time-axis perturbations break). Documented and not buried. Proposed mechanism for the non-monotonic scaling result: hub marginalization in deep ViTs (arXiv:2511.21635). Deeper models can over-shoot from "single hub aggregator" to a regime where extra layers scramble information rather than refine it. V-JEPA's dense predictive loss explicitly pushes against single-hub aggregation; if the 2B variant has crossed into the over-communication regime while the distilled 300M retains controlled mixing, the pattern is what hub marginalization predicts. Code, reproducibility manifest, raw shards: https://github.com/poisson-labs/vjepa-stress Full writeup: https://poissonlabs.ai/research/vjepa-2-1-robustness Happy to discuss methodology, the partitioning interpretation, or the hub-marginalization argument. The image-noise side of partitioning (gaussian/motion blur/low-light CIs all crossing zero) is the part I'd most like skeptical eyes on. submitted by /u/poisson_labs [link] [comments]

I built a “Living Docs” system for long-term AI coding workflows

English is not my first language. AI actually told me to post this here, and also helped write this post 😅 After months of AI-assisted coding, I kept running into the same problems: - repeating architecture context every session - stale docs - conflicting rules - context drift - AI modifying wrong parts of the project - knowledge disappearing between sessions So I started building a documentation system specifically for AI workflows. The idea became something I now call “Living Docs”. Core idea: The same agent that changes the code is also responsible for maintaining the documentation and operational memory. But there is one important constraint: Documentation is NOT updated automatically after every task. The human confirms the code is correct first. Then the agent performs a deliberate “doc sweep” to sync the docs. Otherwise wrong code can mutate the docs, and then future sessions start treating incorrect behavior as truth. Some core rules from the system: One file owns each rule. No duplication. If a rule exists in two places, you now have two sources of truth, which means you have none. Code is primary truth for behavior. Docs are primary truth for intent. The docs are not static reference material. They act as institutional memory shared between humans and AI across sessions. The architecture has 3 layers: - codebase - LLM-maintained docs - governance/schema layer The governance layer tells the agent: - which docs to load - which file owns what - when documentation updates are allowed - how to prevent duplication and context drift Still experimental, but it already improved long-session stability a lot for me on larger projects. Repo: https://github.com/Diew/living-docs Would genuinely love feedback from people working with Cursor, Claude Code, Aider, Roo, OpenHands, etc. submitted by /u/RenAzure [link] [comments]

Four free Claude Code skills from building an iOS/macOS app with Claude

These skills came out of building Stuffolio, a Universal iOS / iPadOS / macOS app, and they're skills I use often. All four are free, Apache 2.0, no paid tier. Each link below has a sample of the actual output if you want to see what comes back before you install. prompter rewrites your Claude Code prompt for clarity before it runs. It resolves "that file" to a path, sharpens vague verbs, and restructures stacked questions. Importantly, it skips rewriting when the prompt is already clear, so it doesn't add friction to the easy ones. Worked examples across 8 categories. tutorial-creator turns a file from your own project into an annotated reading tutorial with vocabulary tracking, pre and post tests, and prerequisite gap analysis. Language-agnostic. Sample outputs: a starter walkthrough and a more advanced one. bug-echo is the after-fix sweep. Once you fix a bug, It reads your fix, confirms the anti-pattern, then scans the codebase for other instances of the error. Each match is read in context and classified BUG / OK / REVIEW. It honors #if os(...) blocks, so Universal codebases don't surface false positives across platforms. Sample report from a real run. bug-prospector is the forward-looking audit. It runs 7 lenses (assumptions, state machines, boundaries, data lifecycle, error paths, time-dependent bugs, platform divergence) to find code that compiles fine and passes tests but breaks under conditions you haven't exercised yet. It asks up front whether the project is iOS, macOS, or Universal so findings respect your platform set. Works well with bug-echo. Run prospector before releases, echo after prospector fixes. Sample report. Happy to answer questions, and I appreciate any feedback. (Disclosure: Stuffolio is my app; the skills are independent of it and free to use anywhere.) submitted by /u/BullfrogRoyal7422 [link] [comments]

Keeping a Claude Code session running 24/7 (and accessible from my phone) without leaving the terminal

Disclaimer: While I did use Claude Code to help build this, all code has been reviewed by a human, and I've been using this for weeks without any issues. I do most of my Claude Code work in the terminal. The web/desktop apps are fine, but claude in tmux is where I actually want to live. It's always the same shell, same dotfiles, same MCP servers, same skills, no context-switching to a different surface just because I'm replying from my couch. Problem: a terminal session dies when the terminal dies. And there are real things I want a long-running agent to do, like answer me on Telegram while I'm out, run a daily brief at 7am, sweep my inbox at lunch, spawn a fresh coding agent on a worktree when I want to work on something. So I built Leo: a process supervisor and scheduler for the claude CLI. What it does Supervises long-running claude processes. Each runs in its own tmux session with auto-restart. I run one as my personal assistant, wired to Telegram via the --channels flag. Personality and operating rules can live in a custom subagent file or CLAUDE.md, which means the same identity travels with me into terminal sessions too — no syncing memories/MCPs/skills between two systems. Cron-driven tasks. Standard cron syntax, prompt-from-file, optional channel notify on failure. Mine fires daily briefings and inbox sweeps. Ephemeral coding agents from templates. leo agent spawn coding blackpaw-studio/leo gives me a fresh tmux session with a claude REPL pre-cloned into that repo. With remote-control on, the same agent shows up in the Claude app too. The leo CLI doubles as a thin SSH client, so I can manage agents on my Mac Mini server from my laptop without leaving the terminal. One daemon, web dashboard, token-authed HTTP API, MCP server. Every channel gets /clear, /compact, /agent spawning, /tasks management for free. Channel-agnostic on purpose. Leo doesn't ship messaging. You install any Claude Code channel plugin (Telegram, iMessage, Discord…) and reference its ID in channels:. The plugin owns its own auth; Leo just passes the resolved list to the spawned process. Install brew install blackpaw-studio/tap/leo # or curl leo.blackpaw.studio/install | sh # or go install github.com/blackpaw-studio/leo/cmd/leo@latest Prereqs: authenticated claude CLI, tmux. macOS and Linux. Website: https://leo.blackpaw.studio Repo: https://github.com/blackpaw-studio/leo Docs: https://docs.leo.blackpaw.studio submitted by /u/edc1591 [link] [comments]

Building a 9-ball AI player: Candidate generation for direct cut shots [P]

I'm building a 9-ball-player to help with pattern play. There are many ways to make the next ball, and sometimes in more than one obvious pocket. Which should should you choose depends on probability of making that shot AND ending up in a favorable spot for the next shot, that is also amenable to getting good position for the shot after. To that end, I have built the following components: A transformer based model that learns p(win) given a table layout. Candidate shot generator that includes cut shots, bank shots, kick shots, caroms and combination shots as well as safeties. An evaluator that will pick the best shots based on the p(win) model on the resulting state of each candidate shot. The ground truth: pooltool Pool physics is well-modeled but expensive. I use pooltool python library, a solid open-source billiards simulator with accurate ball-cushion-pocket-felt interactions. A single shot takes ~5–15 ms to simulate end-to-end on one CPU thread for the typical 1–3 object-ball layouts that come up in shot evaluation; full racks (9 object balls) push that to ~20–50 ms because there are more pairwise collisions to track. Sounds fast until you do the math. For each layout I want candidate shots into 6 pockets, and each pocket has a 5-dimensional parameter space to search: speed, aim angle, elevation of cue stick, side spin, follow/draw. A naive grid sweep over even a coarse 10 steps per dimension is 100K combinations × 10 ms = ~17 minutes per pocket per decision. Iterative optimizers like CMA-ES bring that down to ~500–1000 sims per pocket, but that's still ~5–10 seconds per pocket, ~30–60 seconds per layout. For training a value network with millions of decisions, that's months of compute. Faster evaluation of candidates The shot selection needs to know if the shot will go without simulating every possible shot. But we don't need the final position of the table just yet. I approached the problem by splitting the shot into what the object ball needs to do and how to hit the cue ball to accomplish that. So the first component for shot making is an Acceptance window lookup. It is pre-computed offline per (object ball position, pocket, speed): the range of OB (object ball)-departure angles that actually drop the ball at different speeds into the selected pocket. This is the "what does the ball need to do" specification; it captures the pocket jaw geometry, the down-the-rail effect, all of it. Then I created a Shot-index lookup table. Given the desired OB-departure angle (measured as deflection from the cue-to-OB line) and the cue-to-OB distance, look up shots that produce that geometry from a pre-computed index using no elevation shots simulated using pooltool sampled on a discrete grid of (distance, speed, aim-offset, spin, draw) keyed by OB departure angle. Lookup returns candidate (speed, aim_offset, spin, draw) tuples that send the OB in the desired angle (distance is fixed by the layout). That was an improvement but it has holes due to discretization. To cover these holes, I built a throw model for continuous space generalization. It is a small MLP to predict OB-departure deviation given (cue→OB distance, speed, aim angle, spin, draw, elevation). It generalizes the shot-index data into the continuous space. Architecture is fairly straightforward. The features are aim_offset, distance, speed, side spin, draw and elevation. Output is deviation from cue-object ball angle. It has 4 hidden layers with 128 dimensions for hidden layers, ReLU activation, ~50k parameters in total. I trained the model over 5M shots (took about 6 hours to generate) and measured the Mean Angle Error over the validation set (~1.1M) which was around 0.2 degrees. I also used the left/right symmetry for the model to use 2x the data so I don't have to worry about taking care of mirroring during play. The beauty of it is that, I can use the shot index to get decent starting parameter set for shots and apply small perturbations across different parameters and evaluate them in a batch using the throw model on a GPU really fast. Speed up in my setup was around 10000x compared to simulating all those shots through the physics engine which makes a world of difference in generating enough self play data. Batch of 1000 candidate shots takes 1 ms to evaluate. Compare that to 1000 simulations x 10 ms on average. I then cluster all the shots that are predicted to fall within the acceptance window of the intended pocket using bucketing around speed, spin and draw. I evaluate representatives from each cluster using the physics engine using noisy simulation that adds execution noise to the shots. We don't want to find that 1-in-a-million shot that can't be executed reliably. Then I use the maximum expected value of the table state after the shot using the p(win) model (which I did not go into in this post) for shot selection. Given I still do physics simulations once I find my candidates, the end-to-end speedup was around 50-100x.