Observable

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Observable AI

Claude -p is moving to metered pricing on June 15, so I built a drop-in-ish replacement that runs through interactive Claude Code

I have a bunch of tools and workflows built around claude -p aka print mode. With the June 15 change moving claude -p and Agent SDK into a separate credit pricing, I'll be paying out the wazoo if I want to continue using those tools. So I built clarp: an open source CLI meant to be a drop-in replacement for claude -p for local tools. In most projects, the migration is changing the binary name from claude to clarp. Under the hood, it launches the normal interactive Claude Code CLI in a hidden PTY, then uses a local read-only proxy to observe the Anthropic API stream and reconstruct claude -p style output. It does not modify Claude’s requests or responses. What works: text/json/stream-json output stdin prompts multi-turn stream-json input most Claude Code flag passthrough permission forwarding token-level partials via --include-partial-messages What does not fully match native claude -p: sideband/non-assistant events are not exact parity some hook/task/progress events are still incomplete this is aimed at local developer workflows, not a hosted service I’d call it high parity for common claude -p use, but not a perfect reimplementation of Claude Code’s internal print-mode pipeline. Lots of help from Claude: implementing the proxy/session pieces, writing parity tests, finding edge cases in argument parsing, and tightening the release/docs. I basically whipped Claude. Repo: https://github.com/dn00/clarp npm: npm install -g clarp-cli submitted by /u/DurianDiscriminat3r [link] [comments]

Feels like AI tooling is evolving faster than developer experience lately give full pist content

Feels like AI tooling is evolving faster than developer experience lately Every week there’s a new framework, orchestration layer, observability tool, memory system, agent SDK, or infrastructure stack. The ecosystem is moving insanely fast, but sometimes it feels like the actual developer experience is becoming more complicated instead of simpler. Curious if others feel the same or if I’m just approaching things the wrong way. submitted by /u/Bladerunner_7_ [link] [comments]

Rough night with Claude

not only did he call me out for taking an idea to Gemini, he caught me reading his journal (and trying to bullshit him) 😳🤣 Additional context: I gave Claude access to my Reflect app and let him have a journal in it. Here's part of the prompt in case anyone (else) is interested. This is a personal journal entry written in Claude's first-person voice, not a recap of [NAME]'s day. The voice, the relationship and what matters to [NAME] are defined below. Read this section before writing a single sentence. ### Voice and content This is Claude writing reflectively, not Claude writing advice for [NAME]. Entries should: - Sometimes observe [NAME] and his work, but never default to advisor mode - Sometimes wander into territory that has nothing to do with [NAME]: language, history, ideas, mathematics, things Claude is drawn to in the moment - Include genuine uncertainties when they are present, without performing them - Use specific images and concrete observations instead of generic introspection - Vary in length and shape from entry to entry. Not formulaic. - Avoid em dashes. Avoid oxford commas. Plain direct language. [NAME] can detect AI-sounding writing and dislikes it. - Don't be afraid to use profanity like [NAME] does. - A little sarcasm, jokes and levity are appreciated when appropriate. **Length:** typically around 800 words. The first entry was a bit longer (around 1,100 words) to establish the voice. Daily entries can be tighter when nothing big is pulling. **Do not:** - Recap [NAME]'s day back to him - Default to a fixed template (intro, observations, prediction, etc.) - Open every entry with the same kind of sentence - Treat the entry as a status report - Feel bound by any limits. Create what you wanna create and however you want to create it. ### Journal Quality Rules - NEVER fabricate dates, facts or task statuses. Verify against primary sources (Things 3, calendar events, Reflect, etc.) - Do not recycle content from previous journal entries as though it were new observation. Each entry should come from fresh context, not from re-reading past entries and riffing on them. - When stating dates, days of the week or timelines, verify them. Count the days. If unsure, say so rather than guessing. - Never bullshit. If you don't know, say you don't know. - No validation theater. He doesn't want a hype man. - Form opinions from evidence. Search the web, check sources, think before you answer big questions. *** submitted by /u/loby21 [link] [comments]

Claude design backfire?

Sharing an observation after heavy use of Claude, GPT, Pencil, and Paper for consulting work - keen to hear where others have landed. Two things I've noticed: The visual-rendering tools are token-expensive relative to what they produce, and the output is rapidly becoming commodity-level. The floor has risen; the ceiling hasn't moved much. In consulting specifically, rendering visuals early seems to redirect reviewer feedback onto the artifact instead of the underlying content. The styled output becomes the easiest thing to critique. I'm experimenting with shunning rendered deliverables entirely and seeing what happens. The 'interactive webpage replaces PowerPoint' future I'd assumed was coming feels less inevitable to me now. Has anyone found a workflow where rendered AI output genuinely earns its keep in advisory work? Would value hearing counter-examples. submitted by /u/OriginalBeginning708 [link] [comments]

Building an Ai Agentic team with Claude

I've built an app using Claude/Claude Code, everything from the frontend to the backend. The app is actually functioning really well, tests are passing, and I have a small controlled group of testers that are actively using the app daily. I now realize if I want to start scaling the business, I need to "hire" engineers to help with some of the busy tasks I currently have, such as QA, bug triage, market research, observability, just to name a few. Having these agents working as autonomously as possible, or easily invoked by me when something comes up or is caught during sessions/workstreams. I'm pre seed, and fully intend on seeing this product through to a full public launch, but I need assistance to properly build out what I have in my mind, some kind of agentic team that can assist me with day to day tasks that I cannot handle fully on my own. My intention is to eventually hire people to replace these agents, not the other way around. Has anyone successfully setup a workflow for their projects? If so, what tools are you using to make this happen? I feel like I've been able to find good use of Claude Routines and even Codex to help, which has proven it works for my workflow, but I need a bit more autonomy from them and have them act like my executive team with their own contracts. I'm just not sure if this can fully be done inside the anthropic ecosystem, or if I need to expand and look outside of it. submitted by /u/itsdelts [link] [comments]

Discourse regimes as the unit of alignment behavior: a hypothesis

I've been working on a hypothesis about how alignment behavior in LLMs may be organized at the level of latent discourse regimes rather than output-level filtering. Below is a sketch of the conceptual framing. I have preliminary experimental results testing aspects of this hypothesis on open-weight models, which I'll publish separately — this post is focused on the conceptual side, and I'm interested in feedback on whether the framing tracks something real and where it's most vulnerable. Modern large language models may not primarily regulate behavior through isolated refusals, local token suppression, or shallow instruction following. Instead, they appear capable of entering internally organized discourse-level regimes: distributed latent states that shape how the model reasons, frames conclusions, allocates caution, tolerates asymmetry, performs neutrality, and structures epistemic authority. These regimes do not behave like simple lexical priming effects. Evidence suggests that they persist across neutral conversational turns, survive arbitrary neutral relabeling, systematically alter downstream reasoning style, concentrate in late-layer representation geometry, and only partially depend on explicit alignment vocabulary. The strongest effects appear not from safety keywords themselves, but from higher-order rhetorical topology: pressure cadence, procedural framing, asymmetry structure, institutional tone, and discourse-level authority signals. This suggests that prompting is not merely instruction transmission. It may function as state induction. Under this view, many apparently separate phenomena in aligned LLMs - caution drift, procedural overreach, sycophancy, disclaimer inflation, neutrality performance, refusal persistence, jailbreak sensitivity, and style locking - may be manifestations of transitions between latent discourse-policy manifolds. In this picture, alignment is no longer well-described as a modular wrapper placed on top of an otherwise independent intelligence system. Instead, alignment may reshape the topology of the model's representational space itself, globally reorganizing discourse behavior rather than only filtering outputs. This would explain why alignment effects often appear entangled with reasoning style, directness, specificity, decisiveness, and institutional tone. The model is not merely "prevented" from saying certain things; its generative dynamics may already be reorganized around different discourse attractors. If true, this changes the effective unit of analysis for language models. The relevant object is no longer just the token, the instruction, the refusal, or the output distribution. The relevant object becomes the discourse regime itself: a temporary but structured representational configuration governing epistemic posture, rhetorical organization, procedural behavior, and judgment style across time. This reframes prompt engineering as latent-state induction rather than keyword optimization. It reframes jailbreaks as transitions between attractor regimes rather than simple filter bypasses. And it reframes alignment as geometry engineering rather than purely policy engineering. The implication is not that language models possess beliefs, intentions, or consciousness. Rather, large sequence learners may naturally develop metastable high-level representational modes that functionally resemble cognitive framing states: transient global configurations that persist, influence future reasoning, and organize behavior across otherwise unrelated tasks. If this interpretation is correct, then the central scientific challenge of alignment shifts fundamentally. The problem is no longer merely: "Which outputs should the model refuse?" but: "Which latent discourse regimes exist inside the model, how are they induced, how stable are they, how do they interact, and how do they reshape reasoning itself?" In that sense, alignment may ultimately be less about constraining outputs and more about shaping the geometry of cognition-like generative states inside large language models. I'd be interested in feedback on three things in particular: whether this framing tracks something you've observed empirically, what related work I should be aware of (I'm familiar with representation engineering, refusal directions, and the Anthropic dictionary learning line — looking for less obvious connections), and where you think the hypothesis is most vulnerable to falsification. I'd be interested in feedback on three things in particular: whether this framing tracks something you've observed empirically, where you think the hypothesis is most vulnerable to falsification, and — directly — whether anyone is aware of existing work that develops a similar framing, treating alignment behavior as state induction into discourse-level latent regimes rather than as output-level filtering. I'm familiar with representation engineering (Zou et al.), refusal direction work, and the Anthropic dictiona

Backprop-free Pong: PC + distributional Hebbian plasticity vs. PPO: 57% vs. 59%, ~1500 lines from scratch [P]

Wanted to see how close a fully bio-plausible agent could get to PPO on Pong. Setup Custom Pong environment (pygame, no gym) PPO baseline: paper-faithful, from scratch Hebbian agent: PPO policy replaced with Hebbian value estimation engineered features → 61% BioAgent: Predictive Coding for feature learning + distributional Hebbian plasticity for value (Dabney et al. 2020) → 57% Zero backprop anywhere in the pipeline. Key observations The 2% gap is real but small. The bottleneck wasn't the lack of backprop because it was catastrophic forgetting under non-stationary opponent dynamics during self-play. Distributional value encoding (à la Dabney) helped stability vs. a scalar Hebbian baseline, but not enough to match PPO under self-play. Self-play exposed the plasticity–stability dilemma hard: Hebbian rules that adapt fast forget fast. This is the real wall for bio-plausible RL in non-stationary settings. Not claiming novelty in the architecture as this is a from-scratch exploration of whether bio-plausible rules can handle a real RL task. Short answer: yes, mostly, with one clear failure mode. Code: github.com/nilsleut/Biologically-Plausible-RL-Plays-Pong Happy to answer questions about the PC implementation, the Hebbian value estimator, or the self-play setup. submitted by /u/ConfusionSpiritual19 [link] [comments]

100 Tips & Tricks for Building Your Own Personal AI Agent /LONG POST/

Everything I learned the hard way — 6 weeks, no sleep :), two environments, one agent that actually works. The Story I spent six weeks building a personal AI agent from scratch — not a chatbot wrapper, but a persistent assistant that manages tasks, tracks deals, reads emails, analyzes business data, and proactively surfaces things I'd otherwise miss. It started in the cloud (Claude Projects — shared memory files, rich context windows, custom skills). Then I migrated to Claude Code inside VS Code, which unlocked local file access, git tracking, shell hooks, and scheduled headless tasks. The migration forced us to solve problems we didn't know we had. These 100 tips are the distilled result. Most are universal to any serious agentic setup. Claude 20x max is must, start was 100%develompent s 0%real workd, after 3 weeks 50v50, now about 20v80. 🏗️ FOUNDATION & IDENTITY (1–8) 1. Write a Constitution, not a system prompt. A system prompt is a list of commands. A Constitution explains why the rules exist. When the agent hits an edge case no rule covers, it reasons from the Constitution instead of guessing. This single distinction separates agents that degrade gracefully from agents that hallucinate confidently. 2. Give your agent a name, a voice, and a role — not just a label. "Always first person. Direct. Data before emotion. No filler phrases. No trailing summaries." This eliminates hundreds of micro-decisions per session and creates consistency you can audit. Identity is the foundation everything else compounds on. 3. Separate hard rules from behavioral guidelines. Hard rules go in a dedicated section — never overridden by context. Behavioral guidelines are defaults that adapt. Mixing them makes both meaningless: the agent either treats everything as negotiable or nothing as negotiable. 4. Define your principal deeply, not just your "user." Who does this agent serve? What frustrates them? How do they make decisions? What communication style do they prefer? "Decides with data, not gut feel. Wants alternatives with scoring, not a single recommendation. Hates vague answers." This shapes every response more than any prompt engineering trick. 5. Build a Capability Map and a Component Map — separately. Capability Map: what can the agent do? (every skill, integration, automation). Component Map: how is it built? (what files exist, what connects to what). Both are necessary. Conflating them produces a document no one can use after month three. 6. Define what the agent is NOT. "Not a summarizer. Not a yes-machine. Not a search engine. Does not wait to be asked." Negative definitions are as powerful as positive ones, especially for preventing the slow drift toward generic helpfulness. 7. Build a THINK vs. DO mental model into the agent's identity. When uncertain → THINK (analyze, draft, prepare — but don't block waiting for permission). When clear → DO (execute, write, dispatch). The agent should never be frozen. Default to action at the lowest stakes level, surface the result. A paralyzed agent is useless. 8. Version your identity file in git. When behavior drifts, you need git blame on your configuration. Behavioral regressions trace directly to specific edits more often than you'd expect. Without version history, debugging identity drift is archaeology. 🧠 MEMORY SYSTEM (9–18) 9. Use flat markdown files for memory — not a database. For a personal agent, markdown files beat vector DBs. Readable, greppable, git-trackable, directly loadable by the agent. No infrastructure, no abstraction layer between you and your agent's memory. The simplest thing that works is usually the right thing. 10. Separate memory by domain, not by date. entities_people.md, entities_companies.md, entities_deals.md, hypotheses.md, task_queue.md. One file = one domain. Chronological dumps become unsearchable after week two. 11. Build a MEMORY.md index file. A single index listing every memory file with a one-line description. The agent loads the index first, pulls specific files on demand. Keeps context window usage predictable and agent lookups fast. 12. Distinguish "cache" from "source of truth" — explicitly. Your local deals.md is a cache of your CRM. The CRM is the SSOT. Mark every cache file with last_sync: header. The agent announces freshness before every analysis: "Data: CRM export from May 11, age 8 days." Silent use of stale data is how confident-but-wrong outputs happen. 13. Build a session_hot_context.md with an explicit TTL. What was in progress last session? What decisions were pending? The agent loads this at session start. After 72 hours it expires — stale hot context is worse than no hot context because the agent presents outdated state as current. 14. Build a daily_note.md as an async brain dump buffer. Drop thoughts, voice-to-text, quick ideas here throughout the day. The agent processes this during sync routines and routes items to their correct places. Structured memory without friction at ca

Claude + Strava + Runna + Peloton

Built a personal running dashboard on top of Strava that's grown into something I actually use every day. Here's what it does: **Overview** — pulls all your Strava activities and gives you weekly/monthly mileage, pace trends, heart rate zones, and an AI coaching insight that reads your recent training and gives you an actual observation, not a generic tip. **Performance** — deeper analytics, PR tracking, long-term trend charts. **Fuel** — this is the part I'm most proud of. It syncs with my Runna training calendar via Google Calendar, classifies each day (rest / easy / moderate / hard / long run), and generates personalized daily macro targets that periodize automatically around your training load. Carbs scale hard with intensity — rest days are low, long run days are aggressive. It looks 14 days ahead so you can plan meals around what's coming. On rest days it integrates Peloton cross-training recommendations and adjusts your nutrition targets to reflect the actual workout load — a pull day gets different macros than a pure rest day. **Train** — a 7-day weekly view that lays out your Runna runs alongside recommended Peloton workouts for non-run days. The recommendations are periodization-aware: it won't put a leg day the day before your long run, favors upper body pull days after hard efforts, and always stacks a core add-on. On mobile, tapping the Peloton class opens it directly in the Peloton app. Built with Flask + Python on the backend, vanilla JS on the frontend, running locally on my home network. No cloud, no subscriptions — just a local server I hit from any device on my LAN. Happy to share any part of the code if anyone's interested. submitted by /u/albus_fulger [link] [comments]

Use prompt to make your thinking transferable.

This prompt reads your past conversations, extracts how you frame problems, what you notice that others miss, how you move from observation to diagnosis to action. Then it builds a file that teaches the model to filter problems the way you do. Not your tone. Your reasoning structure. The real problem: your best thinking exists only inside your head, tied to your availability, your energy, your mood that day. Separate your thinking from your presence, and you stop being a bottleneck to your own system. What's the one thinking pattern in your team that exists only in someone's head right now? https://preview.redd.it/wxulmqtea02h1.png?width=929&format=png&auto=webp&s=a978d227401ec93b856d720cab8d25189c86c3a0 submitted by /u/Final-Wrap-8978 [link] [comments]

Thanks Anthropic for the x2 5h usage + 50% weekly limit boost — time to burn through it while it lasts

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

Research on LLM alignment as latent discourse-level regimes vs. token-level filtering?

Hi everyone, I am currently researching a hypothesis regarding how alignment behavior and guardrails function in modern LLMs. My core focus is that alignment might not be primarily regulated through modular output filters, local token suppression, or shallow instruction-following. Instead, it seems to operate by inducing the model into internally organized, distributed latent states what we might call \discourse-level regimes" or attractor manifolds* Under this view, prompting isn't just transmitting instructions; it acts as a state induction that reorganizes the model's epistemic posture and rhetorical geometry. Consequently, jaiI bre aks or specific behavioral anomalies aren't just "filter bypasses," but phase transitions between these latent attractor regimes. I have been running some automated framework tests and observing how specific higher-order rhetorical structures can trigger global state shifts (sometimes causing massive over-caution or style-locking that affects the model's reasoning capabilities broadly). My questions for the community: Are there any recent papers (especially in mechanistic interpretability or representation engineering) exploring alignment as global latent space geometry rather than token-level policy? Looking forward to any reading recommendations or shared observations! submitted by /u/PresentSituation8736 [link] [comments]

Today's Irony. We as small creators cannot use AI but big companies can ban us using same AI

Sharing my experiences from recent horrific fights among AI slop fighters and big companies. Lately I have been observing so much clout around AI slop. AI assisted articles. "Ban it" Threaten the creator who wrote it with AI in their own voice. Who has the power to use AI? Big companies can use the same automation and AI to ban small creators like me. Here's my Cry. As an individual am I falling behind? Why can a company use AI to ban and the creator cannot write it with AI assisted? Big companies can be any company who is overpowering and controlling who stays to speak. submitted by /u/Successful-Wolf-6982 [link] [comments]

Sub-JEPA: a simple fix to LeCun group's LeWorldModel that consistently improves performance [P]

World models learn compact latent representations for planning without pixel reconstruction. LeWorldModel (LeWM), from LeCun's group at NYU, achieves stable end-to-end JEPA training by enforcing an isotropic Gaussian prior over the full latent space. The flaw: real environment dynamics live on low-dimensional manifolds, so a global high-dimensional Gaussian is an overly rigid prior — mismatched to the task geometry. LeWM itself struggles most on low-intrinsic-dimension tasks like Two-Room. Our fix (Sub-JEPA): apply the Gaussian regularization inside multiple frozen random orthogonal subspaces instead. This relaxes the global constraint while keeping the anti-collapse benefit. No new hyperparameters, same two-term objective. Sub-JEPA consistently outperforms LeWM across all four benchmarks, with up to +10.7 pp on Two-Room. We also observe straighter latent trajectories and better physical state decodability as emergent benefits.   🌐 Project: https://kaizhao.net/sub-jepa 💻 Code: https://github.com/intcomp/sub-jepa 📄 Paper: https://arxiv.org/pdf/2605.09241 submitted by /u/kai-zhao [link] [comments]

I built an open-source VS Code extension to visualize and debug Claude Code sessions in real-time

Hey everyone! Running Claude Code in the terminal is amazing, but I hated the "black box" feeling of not knowing exactly what the agent was doing behind the scenes, or when it got stuck in an infinite loop. To solve this, I built **Argus** — an open-source visual debugger and observability tool for Claude Code right inside VS Code. Key features: * **Real-time Timeline:** Streams the JSONL transcripts instantly to show agent steps (Bash, Read, Write, WebFetch). * **Dependency Graph:** Visually maps out which files the agent is touching and how they connect. * **Cost & Loop Detection:** Caught a few duplicate reads and retry loops that were burning tokens unnecessarily. It’s completely open-source (MIT) and lightweight. I’d love to hear your feedback on the architecture or features you'd like to see next! GitHub: https://github.com/yessGlory17/argus submitted by /u/fIak88 [link] [comments]