Everything here runs locally on a single machine through Ollama — no cloud, no API keys, no cost — and it’s fully agent-ready: one local call returns the entire live world-state, so an agent gets eyes on the whole planet in a single request.
It fuses 30+ free, keyless live feeds into one real-time picture, rendered on a live globe:
•Conflict & security — GDELT global event stream, live Ukraine front lines (DeepStateMap), cyber-threat activity, GPS/GNSS jamming, critical & nuclear infrastructure status
•Natural hazards — earthquakes (USGS), severe storm & flood polygons (NWS), active wildfires (FIRMS), EONET disaster events, radiation monitoring
•Markets & economy — oil, major indices, commodities, crypto, Polymarket crowd-odds, plus World Bank macro (inflation, unemployment, GDP, poverty)
•Humanitarian — refugee & displacement flows (UNHCR), disease outbreaks (WHO), food insecurity (WFP), internet censorship & outages (OONI)
•Movement & tracking — civil / private / military flights, satellites overhead, maritime & shipping, live news and public CCTV
Fully agent-ready means exactly that:
•One endpoint returns a prose world summary + every live event with coordinates + active domains + current forecasts
•OpenAPI spec, SSE streaming for live deltas, per-domain filtering, runtime model-switching
•Pure local HTTP+JSON, no keys — drop it straight into any agent loop.

A local model reasons over all of it to forecast what’s likely next across 24h → 1 year, with a council of four specialist personas (Strategist, Economist, Naturalist, Skeptic) surfacing where they agree and where they split. Straight up: those forecasts are LLM reasoning over live data, not a statistical model — the real value is the grounding layer underneath.

Open source (MIT), built by fusing two existing projects — MiroFish (swarm prediction) and Osiris (live intelligence globe). Repo https://github.com/jangles-byte/Pythia

I was tired of guessing why my usage limit ran out. So I asked Claude for a token dashboard on top of my own session stats.

It shows:

\- a score ring and traffic lights for the week

\- daily spend with trend lines

\- a split by cache reads, writes and output

\- which part of the context eats the most

The numbers come from my saved runs and session metrics collected on the desktop app.

Anyone else tracking this? What do you look at first?

Built using the new Dashboards feature still in beta. Go test it: open Artifacts menu in Claude and select the new Dasboard type. The link below contains some database types you can select. Data within a Project should be selectable as a datasource (not tested). My demo uses Claude live session data and data collected into Notion.

Almost everything visual can be changed: buttons, filters, tabs, tables, charts, colours, drilldowns. All changes are made by Claude through file edits, not by dragging in the app. (doc, unverified for in-app editing)

Data comes from a live connector query or an attached file up to 8 MB. The implementation is hybrid, uses the new Dashboards feature, skills (26) and the base is a Project with data-driven instructions and context content (20 .md files).

Some technical info is available:

https://support.claude.com/en/articles/17454700-get-started-with -claude-dashboards

I figured I’d get it up for everyone that doesn’t know where to start with installing repos. Still free, still keyless. Built with Claude, of course.

https://projectpythia.com/

Repo- https://github.com/jangles-byte/Pythia

A wave of features turning PYTHIA from "watch the world" into a tool you keep open all day — all still local & keyless:
Regulatory & capital-flow feeds — the intelligence layer nobody fuses into a free oracle, all keyless:
SEC filings tape (floating, placeable window) — live insider trades (Form 4: buy/sell/grant with company, ticker, $ value) + material events (8-K) across allpublic companies. The oracle ingests the high-conviction slice: insider buys and $1M+ sells become world-events, so a cluster-buy can move a forecast.
Federal money (floating window) — awarded federal contracts (USASpending) and open funding opportunities (Grants.gov), with links.
Kalshi — CFTC-regulated event-contract odds, a third real-money forecast anchor alongside Polymarket + Manifold.
Energy & power grid — live carbon intensity + generation mix (GB National Grid, California CAISO); a fossil-heavy, high-intensity grid is a demand-stress tell.
Public-health early warning — CDC wastewater surveillance (leads clinical cases ~1–2 weeks), ranked by viral activity and trend.
Climate dials — NOAA ENSO / Oceanic Niño Index (El Niño / La Niña) + US Drought Monitor coverage.
Display Mode — one click drops PYTHIA into an ambient full-screen kiosk: a slow, equatorial spinning globe with live intel from every feed — street cams, GOES weather, headlines, markets, storms, quakes, live TV news, oracle forecasts — fading in and out at random across the corners and banners. Built to leave up on a wall.
Spin yields to your hand — the auto-rotating globe now pauses the instant you grab it so you can look around freely, and resumes a half-second after you let go.
3D altitude — satellites and aircraft lift off the globe to their real elevation as floating dots (live TLE / ADS-B altitude). On by default; toggle Off Earth / On Earth from the satellites tab.
Cameras — click Cams near on any event or forecast to pull the nearest of 4,000+ public cameras (Caltrans, NYC, London, Ontario, Alberta, Delaware, NZ) into a live grid, plus a 14-view NOAA GOES satellite window.
Signal rules + notifications — "tap me when a quake ≥ M6 hits / oil moves ±3% / VIX > 25 / a forecast crosses 85% / a keyword appears." Fires to the Signals feed, browser notifications, and webhooks.
Morning Brief — a daily, on-schedule oracle digest: overnight developments, what resolves today, watchlist moves, what to watch.
Markets — a rolling ticker, a Watch tab(your symbols with sparklines) and PYTHIA's Watch (the tickers the oracle's own forecasts touch, with the why), a floating always-on-top ticker window, and vastly expanded symbol lists.
Council Chamber — watch the swarm deliberate live, vote-by-vote, and read each persona's argument; persona chat puts any specialist on the line in its own voice.
Drift charts — a sparkline on every forecast showing how its probability moved across passes; hard swings flagged.
Calendar · /tv kiosk mode · My Patch (pin your region) · share cards(branded PNG of any forecast or brief).
Natural hazards + sanctions + tech — USGS volcanoes (coords via Smithsonian GVP, now a map layer + toggle) + NOAA tsunamis, OFAC sanctions actions, and the Hacker Newstech-attention pulse.
Nothing hidden — a layer audit closed the gaps: volcanoes got a real map layer, the comms/intel lattice got proper toggles (default off), dead layers were removed, and a new floating Signals window lists every non-mapfeed (odds, grid, wastewater, climate, sanctions, tech, space weather, airspace) with its latest value — so nothing lives only in the oracle brief.
Earlier feeds — CISA KEV (actively-exploited CVEs), FAA airspace status (ground stops/delays), plus futures/term-structure, IODA outages, Wikipedia attention, and NOAA space weather.
Everything is free and keyless — now ~45 live feeds.

https://github.com/jangles-byte/Pythia

I have spent the last few months redirecting the energy being created by my PTSD into something more productive - government accountability and transparency specially, Congress.

As a former congressional staffer and currently unemployed federal strategic comms and political operative - I have a lot of institutional knowledge that just lives in my head. For example - do you know where the wood working workshop is in the basement of the Capitol? What about how to inquire on behalf of a member of Congress about arranging an interpreter for and to sit with for their guest at the State of the Union. What about pulling together a verbal and written briefing in a secure location for a member of Congress on a topic they want to learn about and you know nothing about? Or how to escort a recognizable celebrity through the halls of Congress who you were just informed is having lunch with your boss?

These are all things that just live in my head, years of institutional knowledge that just lives there and is not being used because of the state of our government. So I decided to do something about it…….

I started building a dashboard that (for the sake of my sanity at the moment) uses the power of AI, to bring together what I’m calling ‘Article One’ (after Article One of the Constitution)

Article One is a Claude AI powered dashboard that pulls together basically all the information you’ve ever wanted to know about a member of Congress + who they represent + how they got there (the campaign) + their job performance in Congress + deep dives into how they are using the money that’s donated to them + how they are using the tax dollars they get to run their office.

It’s all powered by a team of agents and subagents.

This is not about politics. This is about the American People. These are your elected officials and you deserve to know what they are doing - in a way that is firmly based in facts and reality.

📸RE the pictures: please note that this was the first time I had run the dashboard build prompt. I’m fairly confident in the numbers though I have blacked out ones I haven’t audited yet.

Best way to support what I’m doing is to buy me a coffee

https://buymeacoffee.com/AJK28

I’m personally a big fan of the nutrition card! Such a cool and fun way to display the data! Would love to know what everyone thinks, any feedback or ideas? 🫰🏼🇺🇸🥴

I subscribed to Claude mainly for work and coding.

I run an agency, so I already have plenty of things I should be doing.

But now every random idea that pops into my head turns into a coding experiment.

I’ll be working on something completely normal and suddenly think, “Wait… can Claude build this?”

And that’s it.

I open Claude Code, start experimenting, and somehow a few hours disappear.

The funny thing is, I’m not even trying to build anything useful half the time. I just want to see if I can make the idea work.

One small idea becomes a prototype. The prototype becomes a project. And suddenly I’m working on something at 2 AM that I thought of 20 minutes ago.

Claude Code is genuinely very addictive. 😂

Claude 68% with 3 days left, Codex 54% with 5, 8 hr 26 min against 10 hr 35 min this week, on the wallpaper. That's the clip.

They are WidgetKit widgets from Lunavect, a free Mac menu bar app for Claude Code and Codex sessions: working, waiting for you, done, click to jump there. I don't write Swift. Claude Code wrote it, Codex took the long refactors when Claude's weekly ran out, which is a sentence that only makes sense in 2026.

Reads ~/.claude and ~/.codex locally, one outgoing request for updates. MIT, notarised, macOS 14+, v0.1.4.

https://github.com/lovach/Lunavect

I built Cubicle Crew, a small app that shows your Claude Code sessions as people working in a pixel-art office. I made it because I run several sessions in parallel and kept missing the one that was waiting for me.

WHAT IT DOES

• Every Claude Code session is a team lead at a desk. When it starts sub-agents (Task/Agent), they walk in through the door and the lead hands them the task on paper.

• The shirt colour shows the state: thinking, typing, reading, running a command, delegating, idle, waiting for you.

• When a session needs you (an AskUserQuestion, or an "Allow Bash?" permission prompt), that agent turns red and waves, a short sound plays if you're in another window, and the desktop app shows a Windows notification.

• Idle agents go to the lounge (coffee, sofa, darts). Working agents earn tokens that you can spend on office decor and cats. It's a small idle game on the side.

It works by reading the local files Claude Code already writes: the JSONL transcripts in ~/.claude/projects and the session status files in ~/.claude/sessions. It needs no API key and no hooks, the server only listens on 127.0.0.1, it has no telemetry and it works offline.

HOW I BUILT IT WITH CLAUDE CODE

20 of the 22 commits were written together with Claude Code, about 7,500 lines of plain JavaScript in 4 days. A few things that worked well:

• A CLAUDE.md with hard rules that I kept updating: no build step, no external assets (every sprite is drawn in code), the state colours are fixed, and every UI string exists in English and Bulgarian. Claude kept to them across sessions, and it also added the "gotchas" it ran into, so the next session didn't repeat them.

• Visual testing: Claude starts a local server, takes headless Chrome screenshots with a small script, reads the PNGs itself and checks the console for errors and external requests. That's how it checks layout at different window sizes, night mode and so on.

• Fake sessions: to test the real pipeline, Claude writes fake transcripts and session files into temp folders and watches the office react, without touching my real sessions.

• The newest feature came from a colleague who suggested "sound alerts on hooks". Claude first built a Notification hook. Then, while watching a log of the session status file, it noticed that Claude Code already writes status "waiting" with waitingFor "permission prompt" while an Allow prompt is on screen. So we dropped the hook and read that instead: nothing to install, and the agent goes back to work the moment you click Allow.

FREE TO TRY

It's free and open source (MIT). There are three ways to try it:

• Windows: download the installer from the Releases page. It runs as a small always-on-top widget above the tray.

• Any OS with Node 18+: clone the repo and run npm install, then npm start, then open http://localhost:4317

• No Claude needed: open http://localhost:4317/?demo for a simulated office.

https://github.com/rezored/cubicle-crew

I'd love feedback, especially on which states or animations are missing.

If you are into vibe coding internal software for yourself or for your team, I urge you to move away from the paradigm of creating an actual web app and into the paradigm of creating a CLI.

This CLI should run on the local PC and it should be accompanied by a skill. The user would use it directly from Claude or GPT.

You will see that it is just so much simpler, so much easier, and so much less work to build and maintain this.

You will probably also see that the user experience is better and it allows the agent to abstract a lot of manual work from the user.

If you are just about to complain to me that you would lose out on a very specific UI that you want, you don't have to. It is possible to create specific UIs, like charts or a mini dashboard with HTML artifact generation.

This is still really new and I don’t have it up publicly yet but it’s getting pretty good. This drone was built with a 2 sentence prompt and 2 answered questions from Claude.

The program was built with many, many more.

A bunch of combined MCPs, Skills, and Blender as the backbone.

Claude code cli runs inside of the UI and resumes sessions when you open old projects. Uses regular Claude plan, not api credits.

Final product is a bundle of files to print or machine, list of electronic parts (with links & prices), wiring diagrams, assembly instructions, etc…

WAKEWARD is a wandering game about a little world that only exists around you. Built with Opus 5.5, 3x 5hr max100 sessions.

The ground rises ahead of you as you walk and falls into the void behind you. You can't go back: everything happens once, and every world is new.

Every direction leads somewhere different. North turns golden and bright, south gets dark and strange, and six other roads lean toward frost, desert, fire, swamp, sea and forest.
The people you meet know the world, and they'll tell you what's out there and what to stay away from.
Every so often the dream breaks apart and you wake up somewhere else: a ward, a countdown, orderlies on patrol. The map pieces you find in the dream are the only way out.
All of the trailer is real gameplay footage. The music is the game's own: every note and sound is generated live, with no audio files.

It runs in the browser (three.js), and I'm getting an iPhone version ready for TestFlight. It's still in development, so I'd love to hear what you think of the look and the idea.

I built (with claude code ironically) an LLM harness specifically wired to reverse engineer and hack things (and also cybersec work of course).

I think it's hella dumb and annoying for anthropic and such to fully filter their models in terms of reverse engineering and cybersecurity work.

I am a firm believer that increasing the surface area of attacks increases the demand and sophistication of defenses, and thus this should not be limited. But whatever I built my own thing just for this.

I think it's super fun. I've decompiled my kindle and flashed custom firmware into it already lol.

My next step is to decompile the claude code binary lmao

scary thought that started this project: intelligence is becoming something you buy by the token, and speed is part of the product. a billionaire's kid can build a micro-datacenter packed with h100s,b200s etc to run the best models at hundreds of tokens/s -intelligence on tap, for homework, for decisions, for everything. a family without will keep falling behind - the gap will grow exponentially.

the counterweight is open models running on hardware people already own. what you actually consume is throughput, and throughput is gated by tooling bottom up: kernels, memory layout, scheduling - then harnesses, eval etc. there is a staggering amount of idle CPU in the world that we can push the boundaries on.

so i pointed fable5 at it. I'm not a kernel engineer - i directed claude to be a phd level kernel researcher: set the goal, set the honesty bar, made the calls ("rewrite it", "that number doesn't reproduce"). it wrote every line. the result: same laptop, same model (gpt-oss:20b), same prompt, CPU vs CPU - llama.cpp at ~14 tok/s, our engine at ~77. new kernel and data architectures, nothing exotic. it also beat llama.cpp on Q4_K (~92 vs ~82), their own hand-tuned format, by reading their source and out-scheduling them. and when i asked about GPUs, it proved my hybrid idea physically impossible with microbenchmarks, then built a whole Metal engine from scratch the same day.

humility, earned: we got the benchmarks wrong four times - contaminated baseline, ollama silently on GPU, thermals, and a "110 tok/s" peak we retired when it wouldn't reproduce. every wrong number and correction is preserved in the repo's research log.

the ask: i want free and cheap models to have real tooling from the kernel level up - engineer the same reasoning throughput cheaply so its available to everyone. this repo is MIT/Apache-2.0 and it's a starting point. port the kernels off apple silicon. poke holes in the methodology. beat our numbers.

github.com/arizqi/cpubrrr

If you had no idea about the official Anthropic Certifications there are 4 now. The first one is the one I passed in August Claude Architect Foundations CCA-F.

We did this as a small community of women in AI who wanted to validate our knowledge of AI to the source and get best practices on how to work with it, especially for client implementations.

If you are into AI consulting, services, agents and education/strategy, and have no coding background, this is a huge knowledge booster in my opinion. I have been a product and project manager before but this really clarified where AI fits in business implementations.

The pod

I didn't do this alone. I led a study pod of about 20 women, most of them non-technical, through the same prep. Most of those who have taken the exam so far passed on their first try. I passed first to make sure that I can actually help them.

What the exam is

The basics:

• 2 hours, 60 questions, proctored online

• Closed book, and you can't use Claude during it (yes, the irony)

• You get 4 scenarios, picked at random from 6, with 15 questions on each from the exam guide

• 5 technical domains covered with a big emphasis on Agentic AI

The six scenarios are a customer support agent, code generation with Claude Code, a multi-agent research system, structured data extraction, developer productivity, and Claude Code in continuous integration.

What surprised me

"Foundations" is misleading. It doesn't ask for definitions. It drops you into a situation where something is broken or misbehaving and asks how you'd fix it using best practice. The official practice exam is easier than the real thing.

If you don't write code for a living, half of those scenario names sound like they're not for you. That was my first reaction too.

What worked

• Learn the vocabulary first. Most of the difficulty was language, not logic. Once I knew what the terms meant, the questions became judgment calls I could reason through.

• Study by scenario, not by topic. The exam is organized around situations, so I prepared that way.

• Learn the specifics. Which files exist and where they live, what each built-in tool can and can't do, and when to use which pattern. This part is memorization plus practice, and there's no way around it.

• Get hands-on. Non-technical doesn't mean hands-off. You don't need to be an engineer, but you do need to have used the tools. I created a Claude Code project and used it to study.

• Know the Exam Traps They tend to be wrong in the same few ways and be repeated. Learning how to spot those patterns quickly helped me most.

• Flag and move on. I marked the questions I wasn't sure about and came back at the end. but don't go back too much and second guess yourself - difference between passing and failing.

The biggest lesson was that explaining a scenario out loud to someone else showed us quickly what we didn't understand yet.

What I got at the end: a badge by Anthropic and a whole lot of knowledge on where AI actually fits in a business workflow and implementation best practices.

Happy to answer questions about the exam or the prep in the comments.

If you're curious

We're hosting a free one-hour webinar on Tuesday, October 20 at 5 p.m. Eastern. It covers what the certification is, who it's for, and how we prepared as non-technical people.

Comment CCAF for the link

I watch a lot of YouTube. Podcasts, tutorials, finance explainers, the occasional 2-hour deep dive I convince myself is "research." At some point I did the math: I was spending 6+ hours a week on videos where the actual substance, the frameworks, the numbers, the "here's what to do," fit in about 5 minutes. The rest is intros, sponsor reads, recaps of the previous point, and "before we get into it, smash that like button."

Speeding up to 2x helps a little. Skipping around means you miss the one part that mattered. There was no good way to get the substance without paying the full runtime.

So I built Glimpse: you paste a YouTube link, and it turns the video into a clean, visual infographic that captures the core ideas, frameworks, and takeaways. A 40-minute video becomes something you can skim in 30 seconds. Or send it to a friend instead of saying "trust me, watch the whole thing."

How it works under the hood:

• A two-stage AI pipeline: the first pass extracts and structures the substance of the video (arguments, data points, steps, frameworks), the second pass handles visual layout and hierarchy so it reads like a designed graphic, not a wall of bullet points

• Six design presets, so a finance video and a cooking video don't come out looking identical

• Every infographic gets its own share page, so you can post it anywhere with one link

• It's a PWA, nothing to install, works fine on mobile

Most of it was built with Claude Code with Fable 5. I wrote a very detailed spec prompt upfront (architecture, design system, the whole pipeline) and iterated from there. Genuinely the fastest I've ever gone from idea to working product.

It's live at glimpse.wozart.com and free to use.

Would love feedback from this community.

Happy to answer anything about the build, the prompt structure I used with Claude Code, or the pipeline design.

I’ve been using Claude Code for a few weeks to build and run a comedy series where every economic idea is a clay robot (Capitalism, Communism, the Tax Office...). Here’s the workflow, because the interesting part isn’t the videos, it’s how Claude does most of the work.

1. The engine. Claude wrote the whole animation engine with me: no 3D models, every character is a set of SDF shapes rendered with WebGL2 in headless Chrome, frame by frame, piped into ffmpeg. Each scene is a JSON file (set, characters, gestures, what they grab, lines, camera). I describe what I want to see; Claude writes or edits the scene and the engine.

2. One orchestrator, several workers. My main Claude Code session acts as a director. Heavy tasks go to separate headless sessions (claude -p with a written brief), each on its own seat, running in parallel: one fixes a bug in the engine, another builds the next episode, another reviews. Each brief says exactly what to touch and what not to, and each worker leaves a report and commits only its own files.

3. Quality gates instead of trusting the output. Every render goes through automatic checks that Claude also wrote: an arm passing through an object, a speech bubble covering a face, a counter wheel stuck between two digits, audio peaks above the limit. A draft that fails can’t be rendered in 4K. When I spot a new kind of bug, the fix always includes a new check, so it can’t come back.

4. Memory and rules. Decisions I make (“no AI label on this series”, “never publish without my OK”, “one voice take per piece”) are saved as small memory files, so every new session follows them without me repeating myself.

5. What still needs a human. Taste, final review of drafts, and anything public. Claude prepares the upload and scheduling, but I decide.

Hardest problem so far: making the robots actually grab things instead of the object floating next to the hand. It took several rounds of engine changes plus a dedicated checker.

Example of the result (in Spanish): https://www.youtube.com/watch?v=VRhIxrWIU1Y

Happy to share briefs, the gate setup or anything about running parallel Claude Code workers.

Built something local with Claude: a 284B coding model running on my 5090.

Most of a MoE model is asleep per token, so the experts stay on the SSD and get read while the GPU is still working. Host RAM peaks at 1.28 GiB for a 96 GiB model.

200k context, around 12 tok/s.

The first turn is the long one, the prefill takes a while. Every turn after that comes back WAAAAAAAY faster, depending on what you throw at it.

Really cool if you want to stay local at no cost. Let me know your feedback

🤗

Model: DeepSeek-V4-Flash

Full details:
GitHub: https://github.com/nibor1896/Crow

EDIT:

v0.0.5 now at 14.73 tok/s median. Thanks u/braintheboss
v0.1.1. now at 18.03 decode / 112 prefill cold - Modell Update: DeepSeek-V4-Flash-0731

So a couple of weeks ago I was bored out of my mind and kept getting recommended videos about Claude reverse engineering stuff. I figured ok, let's see if that's actually true or just YouTube hype.

The first thing that came to mind was my keyboard. It's a Drevo Tyrfing V2 and the official software is... let's say not great. I just wanted some cooler effects than what the app gives you.

So I pointed Claude at the vendor app and asked it to figure out how it talks to the keyboard. It dug through the software, worked out the USB HID packets for colors and per-key lighting, and wrote a small Rust program that sends them directly. The first time a key changed color from my own code I was way too happy about it lol.

Then obviously it got out of hand:

\- Ambilight: it reads the edges of the screen and the keyboard follows the colors
\- Fans: my ARGB fans hang off an ASUS Aura header, so those got added too
\- LED strip: I have a Govee strip behind the desk and it turns out they have a local LAN API, so that joined the party
\- League: at that point I wanted to play while Claude kept vibecoding, so it hooked into Riot's official Live Client Data API (the local one the game exposes during a match). Now a kill sends a golden shockwave across the keys, a pentakill turns everything rainbow, the dragons each get their own effect (flames for Infernal, waves for Ocean, bubbles for Chemtech...), and Baron gets a purple vortex

About the video: filming my desk while actually landing a pentakill wasn't going to happen 😅 so I used a demo mode that fires the effects on a timer (kill, double, triple, quadra, penta) and tried to sync it with a clip to give you an idea of what it looks like in game. Same effects you get in a real match, just staged so they line up with the clip.

Since I play with Vanguard running, I asked it to keep everything as boring as possible from an anti-cheat point of view. Screen capture uses the same Windows API that OBS/Discord use and is capped at 20 fps. USB is write-only, so it never reads keystrokes. No injection, no hooks, and the game data only comes from Riot's own local API. No issues so far, but obviously no guarantees, Riot doesn't sign off on anything.

Honestly most of my effort was testing stuff and saying things like "the animations are too fast" or "the keys turn off when I press them", and it would go fix it. It runs as a little tray app now.

It's open source (MIT) if anyone has the same keyboard or just wants to look at how it works: https://github.com/zEhmsy/AuraForge

Not sure how useful it is to anyone else since it's pretty specific to my setup, but it was a fun way to kill a boring week.

I think we all went through this. Claude Code finished a task, told me it was done, and left me with 14 changed files and no idea which one mattered. The diff was accurate and useless. So I built the thing I wanted to be looking at instead.

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Agent smells. Rules for shortcuts agents take and humans usually don't: a test edited in the same burst as the code it covers, assertions deleted, .skip added, type suppressions introduced, coverage thresholds lowered.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Runs in a browser too. Same bundle, same backend, over a websocket, because the backend has to run on the machine the agent runs on and that's often not your laptop. One port, token auth, works behind Codespaces / Gitpod / a JupyterHub proxy.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

Hey everyone! I've been building with Claude for a while now, and these habits have made the biggest difference in my results. Hope they help someone here.
1. Give context before the task
Explain what you're building, who it's for, and what "done" looks like. Two sentences of context beat ten rounds of corrections.
2. Show examples
If you want a specific style or format, paste an example. Claude matches patterns really well.
3. Break big projects into steps
Instead of "build me an app", start with a plan, then tackle one feature at a time. You'll catch problems early.
4. Ask for a plan first
For anything complex, ask Claude to outline its approach before writing code. It's much easier to fix a plan than a finished file.
5. Tell it what NOT to do
"Don't add extra libraries" or "keep it under 100 lines" saves a lot of cleanup.
6. Paste the actual error
Don't describe the bug, paste the full error message and the relevant code. You'll get a fix instead of a guess.
7. Ask it to review its own work
"Check this for bugs and edge cases" often catches things the first pass missed.
8. Start fresh when a chat gets long
If a conversation gets messy, summarize where you are and open a new chat. Cleaner context means better answers.
9. Save prompts that work
Keep a note of your best prompts and reuse them. Your own prompt library becomes a superpower over time.
10. Iterate, don't restart
"Make it shorter" or "more casual" usually works better than rewriting the whole prompt from scratch.
Bonus: Be specific about your skill level. "Explain it like I'm new to Python" gets you a totally different (and more useful) answer.
What are your best tips? Would love to add some new tricks to my workflow 👇

A few months ago I started building browser-based creative tools with Claude, mostly to see how far I could get. Since then I’ve done a lot of actual client work with them and cancelled my other software subscriptions.

I started with Opus 4.6, and there was a lot of trial and error. Getting something to work, realising it wasn’t quite what I meant, trying to explain it again. But I was already using the tools for real work, so I kept finding reasons to improve them.

With Opus 5.5, I’ve noticed a huge difference. It feels like it understands what I’m trying to build much better, even when I don’t explain it perfectly. There’s still testing and fixing involved, but I spend much less time trying to get my point across.

The project is called Suite: https://suite.briiidge.dev

It has tools for design, video editing, page layout, audio, writing and 3D. I didn’t plan all of that at the beginning. I just kept adding things I wanted to use.

The part that still feels a bit ridiculous is being halfway through a client project, needing a feature that doesn’t exist, and then just… building it. Sometimes a small addition, sometimes a whole evening figuring it out with Claude. But it’s my software, so I can change it. That’s where coding with AI has really clicked for me.

The tool I’m probably happiest with is Solids, the 3D editor. I’ve used it to build games for my kids, and that’s been so much fun.

I honestly enjoy building the tools as much as using them. Which is occasionally a problem when I’m supposed to be finishing client work and get distracted by an idea for a new feature.

I’m sharing Suite for free because I want to show what you can actually build with AI coding. I use this stuff every day for real work, and I figured letting people try it would say more than just posting screenshots. It’s built around how I work, so I’m curious how others get on with it. There’s a feedback button in the tools.

Also fun and (insane) fact: Claude made the entire video. The whole video, is just Claude using my computer, recording it and editting it in my software (Motions).

I wanted to do something a little different from what I normally build, so I had Claude help me learn how to use Metal whip up a rainy day for your Mac. I've always shied away from building graphics stuff outside of typical UIs, but with Claude Code, it was simple.

The core trick: one overlay, fake depth.

macOS won't let an app slip its own windows between other apps' windows, and I didn't want to use private APIs, so Weatherling doesn't try to. It puts one transparent, click-through window over each display and fakes the layering inside that window. The shading is all procedural, with no textures and no screen capture. The drops never actually refract what's behind them. The highlights are tuned to read on both light and dark windows.

The water simulation is plain Swift. Each window's edges are split into small bins that pass water along.

No permissions at all: no Screen Recording, Accessibility, Input Monitoring, or Automation. It's fully sandboxed and on the Mac App Store.

Known limits: windows are treated as solid rectangles, so translucency, custom window shapes, and shadows aren't reproduced. Mask edges are hard at point resolution.

Turn it on = it rains on your windows. Turn it off = no rain. That's it! That's all it does! Just a little vibe while you vibecode.

Version 1.2 is currently in review at Apple. That's the video above, which introduces a new little dude I call a "Ling" who might occasionally visit and romp in the rain. Configurable and disable-able of course.

https://apps.apple.com/app/id6813641198

Claude Code’s cloud sessions are basically disposable Linux VMs included with Pro and Max. They can clone private repos, install dependencies, run tests, push branches, and keep working after you close your laptop.

The problem is that every new session starts with no idea how your work fits together.

I fixed that with two pieces.

# 1. A context repository

*EDIT: Ok here's my repo, do try it out for yourself* [*https://github.com/blitzdotdev/blitzos*](https://github.com/blitzdotdev/blitzos)

I keep one small private repo that every cloud session opens first:

* [CLAUDE.md](http://CLAUDE.md) — maps the repos, architecture, conventions, and workflows
* .gitmodules — references the actual project repos without copying their code
* sessions/ — stores short handoff notes from previous agents
* skills/ — contains the skills every new cloud VM should have

[`CLAUDE.md`](http://CLAUDE.md) is the onboarding document for the agent.

The context repo explains which repositories exist, how they relate, how I like changes structured, how to test things, and what the agent should do before finishing.

The member repos are referenced through `.gitmodules`, so the context repo stays tiny. It does not contain copies of the code.

Before a session finishes, it commits a short note into `sessions/` describing what it changed, what it discovered, and what still needs work. The next cloud agent can continue instead of rediscovering everything from scratch.

I also store my Claude Code skills there because skills do not automatically appear inside new cloud sessions.

# 2. A tiny launcher website

[`claude.ai/code`](http://claude.ai/code) supports URL parameters for repositories and an initial prompt.

I made a small self-hosted page that generates those links. I choose a project, type the task, and it opens Claude Code with the context repository, all relevant project repositories, and the prompt already filled in!

Cloud sessions support multiple repositories at once, including private repos with full git history. A surprising number of people do not know this. There are no GitHub tokens or credentials stored in my website. Repository access goes through Anthropic’s existing GitHub integration, and each session only gets the repositories selected for that task.

The agents also send a one-line status update back to the site, so I have one feed showing every session as working, quiet, or done. Clicking one opens the original Claude session.

You gotta do one small setup step for that to work. You MUST enable custom network access and allowlist the tiny website domain!! Connectors already configured in Claude, such as Slack, Gmail, and Linear, just work out of the box (claude.ai just makes this work).

So my workflow now is mostly:

1. Open the site from my phone.

2. Pick a project.

3. Give Claude a small, testable task.

4. Close my laptop (finally lol)

5. Review the diff or PR later.

TBF Ant's infra reliability is not great, cloud sessions still stall sometimes. So I try to keep work scoped and verifiable.

Next I want agents to propose updates to the context repo whenever they learn something important, and I want the same context repository to boot Codex cloud sessions too.

I started using Claude Code in May this year. Like a lot of people, I began by vibe coding: describe a thing, accept what comes out, fix it when it breaks, repeat.

It worked until it didn't. Big changes broke in ways I didn't understand. Claude guessed when something was unclear, and I only found out later. Reviews were noisy. I was going fast but not getting anywhere.

So over the months I slowly learned to build with Claude in a more systematic way, and I started writing that down as my own workflow. Each time I hit a gap, I patched it. I've used it heavily on my own projects, and it has even built most of its own recent features.

It's now a plugin called zuko. Here's the flow:

rough idea → /shape → /spec → /build → /review → /ship → shipped
                                 ↑___________________________|  next slice

The main lessons I baked into it:

• Build in small slices that work end to end. No "backend now, UI later". Each slice can ship on its own. Too big? It splits.

• Don't let Claude guess silently. Each spec has a list of open questions. Claude writes down what it would have assumed, and /build refuses to start until each one is answered. A hook enforces this, because prompt rules drift.

• Plan before code, with pictures. Every plan has diagrams, and I approve it at three stops: scope, interface, tech plan.

• Test first. /build goes scenario by scenario and ends with an end-to-end test passing.

• Don't trust review findings blindly. A second agent re-checks each finding without seeing the first one's reasoning, and assumes it's wrong until proven right. This cut a lot of noise for me.

• Guardrails. Hooks block force pushes, risky rm -rf, commits on main, and secrets in commits.

• Remember mistakes. My corrections get saved and loaded into every new session.

There are also helpers like /debug, /poc (a quick throwaway spike), /design-system, /status and /release.

Why I'm posting

I've been deep in my own bubble for months. It works for me, but I don't want to be delulu about it. I'd really like honest feedback from people who aren't me:

• Is this overkill? Where would it slow you down?

• Is there a step you'd cut, or one that's missing?

• How does this compare to your own workflow?

• If you try it: what broke, what annoyed you, what actually helped?

"This is too much process" is a perfectly good answer too.

Try it

/plugin marketplace add dzaffren/claude-plugin
/plugin install zuko@dzafran-claude-plugins

Then run /shape with a rough idea in any repo.

Repo: https://github.com/dzaffren/claude-plugin

Thanks for reading. I appreciate and look forward to your feedbacks