here's my Claude folder structure that has improved my code quality & the context claude takes. Fix the folder and the output improves. dont touched the prompt.

Five folders

The base structure doesn't need to change:

YOUR-WORKSPACE/
├── system/
├── context/
├── projects/
└── outputs/

Two additions make it hold up once the file count grows: number the top level, add an archive folder.

YOUR-WORKSPACE/
├── [01] system/
├── [02] context/
├── [03] projects/
├── [04] outputs/
└── [99] archive/

[99] keeps archive at the bottom, out of the way but still searchable.

• [01] system/ rules Claude has to follow
• [02] context/ stable reference material Claude should already know
• [03] projects/ active work
• [04] outputs/ finished work
• [99] archive/ old, not deleted

File names carry information Claude uses before it opens anything

dont name files like final.docx, notes.md, screenshot.png. A name should answer three questions on its own: when, what, and what state it's in.

Match the date precision to the file type. Year only for long-term reference files. Year plus quarter for planning cycles. Year plus month for recurring work. Full date for anything task-specific.

Active work, reusable context, and finished work don't share a folder

projects/ gets a numbered workflow because there's a sequence to follow:

[02] Projects/
└── claude-file-system-article/
    ├── 00_BRIEF.md
    ├── 01_SOURCES/
    ├── 02_NOTES/
    ├── 03_DRAFTS/
    ├── 04_VISUALS/
    └── 05_FINAL/

context/ doesn't get numbers. It's a library, not a workflow. No fixed reading order:

[02] context/
├── HOW-I-WORK.md
├── voice-guide.md
├── audience.md
└── references/
    ├── brand-guide.md
    ├── article-examples/
    ├── prompt-library/
    └── source-library/

Reference files don't need to be copied into every project folder. Tell Claude to pull from context/ when it needs them.

Full layout

YOUR-WORKSPACE/
├── [01] system/
│   └── SYSTEM-RULES.md
│
├── [02] context/
│   ├── HOW-I-WORK.md
│   ├── voice-guide.md
│   ├── audience.md
│   └── references/
│       ├── brand-guide.md
│       ├── article-examples/
│       └── source-library/
│
├── [03] projects/
│   └── claude-file-system-article/
│       ├── 00_BRIEF.md
│       ├── 01_SOURCES/
│       │   ├── 2026-06-24_video-notes.md
│       │   └── 2026-06-24_cowork-workspace-notes.md
│       ├── 02_NOTES/
│       ├── 03_DRAFTS/
│       │   └── 2026-06-24_claude-file-system_draft-v1.md
│       └── 04_VISUALS/
│           ├── workspace-map.png
│           └── file-name-structure.png
│
├── [04] outputs/
│   └── 2026-06-24_claude-file-system_final.md
│
└── [99] archive/
    └── old-projects/

Markdown for instructions, numbers for order, names for meaning, dates for search, archive for the noise.

If you got a notice that your data was exposed in KYB Americas' February 2025 breach, you can file a claim now.

Two ways to claim:

• $75 flat cash no proof needed
• Up to $300 for documented losses (credit monitoring, ID replacement, freezing/unfreezing credit, postage) plus up to $100 for lost time (4 hours max, $25/hr)

All eligible class members also get 3 years of credit monitoring, regardless of which cash option you pick.

Who qualifies: US residents who received a data breach notice from KYB Americas.

Note: payments are capped at $250,000 total. If claims exceed that, individual payouts may be reduced on a pro rata basis. Payment also won't go out until after the September 25, 2026 fairness hearing, and later if there are appeals.

Deadline: August 26, 2026.

Here are the top open-weight coding models that you should use at least once.

kimi k3 tops the coding leaderboards, especially for front-end work, but it's too big to self-host, costs more than the others, and hallucinates more than i'd like. You can use it via inference when the problem's actually hard.

glm-5.2 is the one to switch to for daily coding. about a sixth the cost of kimi, drops into claude code with a small config change.

Qwen3.8-max just launched and people are already calling it the best for agent coding. give it a few weeks before betting on it.

deepseek v4 pro leads on raw benchmarks among anything you can actually download, and it's the cheapest to self-host if you've got the hardware.

qwen3-coder-next is the one that fits on a single machine instead of a cluster if local and private is the goal, this is it.

Rent(via inference) the giant ones (kimi, qwen-max), own the smaller ones (deepseek, qwen-coder). "open" mostly means cheaper and more controllable.

I personally haven't tried running qwen3.8-max. anyone uses it on daily basis?

Here are my top claude code commands I use on almost daily basis.

# for instant memory capture

I got tired of correcting Claude on the same project convention every few sessions. Type # at the start of any prompt and it asks which memory file to write to, project CLAUDE.md, user-global, or local, then appends it there.

# Always use pnpm in this repo, never npm

No need to open the file, no manual edit. CLAUDE.md Has slowly turned into a style guide I never sat down to write, which is a strange feeling the first time you notice it.

/resume to pick sessions back up

claude --resume
# or inside an active session:
/resume

Opens a picker with recent sessions, timestamps, first-message previews. Full tool history and whatever todos were mid-flight come right back. --continue With no arguments grabs the most recent session in the current directory (that's the one living in my morning shell alias now).

/compact with a focus instruction

Left on default, /compact throws away whatever I actually needed to keep. It doesn't know what matters to me, so I tell it.

/compact focus on the auth refactor decisions and the failing test output, drop everything about the unrelated CSS work

This keeps a long debugging session in one thread instead of restarting from zero every time the context limit hits.

Hooks for the stuff I'd forget to do myself

Set once in .claude/settings.json. After that it just runs.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "pnpm prettier --write $CLAUDE_FILE_PATH" }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "afplay /System/Library/Sounds/Glass.aiff" }
        ]
      }
    ]
  }
}

Every edit gets formatted, every long task ends with a sound. I stopped noticing it's even happening, which is kind of the whole point of a hook.

claude -p for anything that isn't a chat

git diff main..HEAD | claude -p "Write a PR description for these changes"
cat error.log | claude -p "Classify each line as warning, error, or info"

Add --output-format json if something downstream needs to parse the output. This is the command that changed how I think about Claude Code. It's not just a chat window anymore; it's something I pipe things through.

most of 2025's biggest class-action settlements aren't consumer checks. they're merchants, hospitals, pension funds, athletes. even the ones paid to individuals get split by volume or loss, not evenly.

The biggest ones:

• Visa/Mastercard swipe fees: $38B across 12M+ merchants. That works out to roughly $3,000 "average," but big chains collect millions while small shops collect a few bucks. Payout scales with fees actually paid.
• NCAA "House" NIL: $2.78B over 10 years to ~390,000 athletes. about 75% goes to football and men's basketball. Walk-ons get close to nothing.
• Blue Cross Blue Shield provider settlement: $2.8B, goes to hospitals and physicians, not individuals.
• Poultry wage-fixing: $398M to plant workers, low thousands each depending on tenure.
• Colgate-Palmolive ERISA: $332M to ~12,000 retirees, roughly $20k-$30k each.
• NY taxi/for-hire drivers: $140M to drivers with wrongly suspended licenses, several thousand each.

The settlements that pay a flat amount per person are the small ones, the $50-$150 no-proof checks (Amazon Prime, Hyundai/Kia, data breaches). Those never make a top list, but they're the only ones that really pay like a real "average."

If a headline gives you a total and an "average payout," check who the class actually is first.

if you're repeating a workflow. its better to write it as a skill. A skill is a file that sits in the repo and gets pulled back in whenever the task matches. Doesn;t get pulled on every session only when its needed.

A config file like CLAUDE.md or AGENTS.md pushes instructions into every session whether they're relevant or not. A skill sits idle until the agent reads its description and decides the current task fits, then loads the full body.

here's my guide to writing best skill for your Agent.

The format

my-skill/
├── SKILL.md          # required: metadata + instructions
├── scripts/           # optional
├── references/         # optional
└── assets/             # optional

SKILL.md is the only required piece. YAML frontmatter up top, plain Markdown body underneath:

---
name: code-review-checklist
description: >
  Run a structured code review on the current changeset.
  Trigger when reviewing PRs or before merging any branch.
  Do not use for architecture-level reviews. Use the
  architecture skill instead.
---

The description field does the actual work. It's what the agent reads to decide whether to load the skill at all, so front-load the trigger keywords and say explicitly when it should not fire. A vague description gets you false matches, and those waste context and confuse the routing.

Body is just numbered steps:

# Code Review Checklist

When reviewing a changeset:

1. Read the diff in full before commenting.
2. Check for test coverage on every new function.
3. Flag any function longer than 40 lines.
4. Verify naming follows CONTEXT.md conventions.
5. If a module's public interface changed, confirm
   the changelog entry exists.
6. Summarize findings in a structured comment:
   pass/fail per check, with line references.

here's six steps in 1 file. Now the agent runs the identical checklist every session instead of whatever it feels like that day.

failure modes

Misalignment. You describe the task, the agent starts building, and it turns out you meant something different. What helps here is a grilling skill: before any code, interview me down every branch of the decision. The most popular version of this pattern is three sentences long and has been installed over 250,000 times. Sessions run 16 to 50 questions before code starts, which sounds slow until you compare it to fixing misalignment after the fact.

Verbosity. The agent doesn't know your codebase's shorthand, so a two-word concept in your head becomes a 24-word paragraph in its output, every session, from scratch. A shared-language skill maintaining a CONTEXT.md glossary the agent reads at session start solves most of it. This is just Eric Evans' "ubiquitous language" from Domain-Driven Design, automated.

No feedback loop. Code that looks right and breaks at runtime, because the agent had no test or type check to check itself against. The fix that actually holds is enforcing red-green-refactor as a structural gate: test fails first, then minimum code to pass, then refactor. Not a suggestion, a sequence the skill won't let it skip.

Codebase rot. Agents produce shallow modules because shallow is easy to generate. A weekly architecture skill catches this by scanning for places where understanding one concept means jumping across ten files, or where pure functions got extracted for testability while the real bugs hide in how they're called.

Stateless first

A stateless skill runs and leaves nothing behind, and that's where to start, less to get wrong. Stateful skills, the CONTEXT.md glossary, a progress tracker, persist across sessions but carry more complexity. Add state once you've felt the cost of starting fresh every time, not before.

If a skill runs past two printed pages, it's probably two skills wearing one file.

Community skills aren't vetted by default

Before installing anything from a community directory: read the full SKILL.md, not just the description. Open scripts/ if it exists and check what it touches, anything hitting the network or reading env vars needs an explanation. Check who published it. Test on a throwaway project before using it on important files.

why are companies hesitant to disclose their water use, and when they do, it's cooling efficiency numbers, not actual gallons pulled?

laws passed recently: Virginia's new budget amendment requires the state corporation commission to aggregate water and energy data, but individual facility numbers stay protected as a trade secret. Texas's attorney general ruled that water use counts as commercial data under state code, so it can be withheld from public records. Illinois goes further; SB 2181 requires full monthly disclosure to the state power agency starting this year.

water and energy reporting should be a condition of approval, not something people have to fight for.

Here are settlements with August 2026 deadlines:

1. Esse Health (American Multispecialty Group) data breach deadline Aug 4. ~$50 flat, no proof, plus free medical identity monitoring.
2. Tinder age-discrimination settlement deadline Aug 18. California users who paid for Tinder Plus/Gold while over 29 (after Mar 2015) or over 28 (after Mar 2016). No claim form just select a payment method on the settlement site.
3. McKenzie Memorial Hospital data breach deadline Aug 24. $50 flat no-proof, or up to $4,000 for documented losses, plus 2 years credit monitoring.
4. FitOn (VPPA video privacy) deadline Aug 31. $10 flat, no proof, for anyone with a FitOn account who watched a video Oct 2022–May 2026.

microsoft open sourced skill recorder,

• it records screen, window switches, web, clipboard, terminal, and voice explanation
• github copilot turns that into: task intent → general steps → skill.md → scheduled automation
• not rpa, doesn't replay mouse coordinates. converts clicks into apis, clis, or native agent tools instead
• for example: show it one github issue handled manually, it can generate a skill that batch-processes similar issues
• native support right now: microsoft scout, 365 copilot cowork
• no native support yet for claude code, codex, or opencode, but the generated skill.md can be manually adapted

github.com/microsoft/skill-recorder

We've grown into collecting from clients and paying suppliers in a few different currencies atp. Between the overseas suppliers and a couple of foreign subscriptions, we've got money moving in five or six currencies most months. The tools we use forces everything back to one base currency, so at close I'm pulling spend from a few places and reconciling the FX manually. Every cross-border card charge and wire lands with a markup.

So I'm trying to figure out what people actually run for this. If any part of your money is in more than one currency, what are you using and how do you have it set up?

Researchers looked into 472 large US data centres. about 300 billion liters of operational water use per year, and three-quarters of that isn't cooling servers on site. It's generating the electricity those servers run on.

I find this fascinating because I am seeing a lot of water usage by AI posts on my feed.

cooling water stress hits hardest in water-stressed basins across the western and south-central US. electricity-related water use spreads out regionally, tied to whatever's actually on the grid.

so it's two problems, not one. Some sites need reclaimed water and drought planning. others need cleaner generation further upstream, nowhere near the data centre itself.

what do you think is the bigger issue here? local cooling stress or the water footprint baked into your grid mix?

here's source: salatainstitute.harvard.edu/study-maps-water-footprint-of-ai-data-centers/

here are 9 github repos that can replace your subscriptions.

free-for-dev a running list of free hosting, databases, APIs, monitoring, email, security. basically a stack builder. github.com/ripienaar/free-for-dev

OpenHands reads code, edits files, runs commands. open alternative to devin. github.com/OpenHands/OpenHands

Langfuse self-hosted tracing for prompts, costs, errors, agent runs. alternative to langsmith. github.com/langfuse/langfuse

n8n workflow automation across apps, apis, and models. zapier/make replacement. github.com/n8n-io/n8n

Chatwoot website chat, email, and customer messages in one inbox. intercom/zendesk replacement. github.com/chatwoot/chatwoot

Plane project management for tasks, cycles, roadmaps, docs. jira/linear alternative. github.com/makeplane/plane

Immich self-hosted photo and video backup with albums, search, facial recognition. google photos replacement. github.com/immich-app/immich

yt-dlp downloads video, audio, subtitles, playlists. skips paid downloader tools entirely. github.com/yt-dlp/yt-dlp

Listmonk self-hosted newsletter and mailing list platform. mailchimp alternative, no per-subscriber pricing. github.com/knadh/listmonk

Researchers tested models across every major AI task - text generation, image classification, speech recognition, translation- and compared the biggest, most popular model against a smaller one built for the same job. They measured actual energy use, checked against a physical power meter, so this isn't a guess.

Switching to the smaller model cut energy use by 65.8% on average. Accuracy dropped by only 3.9%. Speech recognition saved 80% on energy. Time series forecasting saved 92%. Translation models barely lost any accuracy while running on a fraction of the power.

In a few cases, the smaller model actually beat the bigger one. Scaling that across data centers globally we can save 32 TWh a year. That's five nuclear reactors put out annually.

Just pick the model that fits the task instead of the biggest one out there.

Speaking of myself, I use the model based on the use case. Whatever is affordable economically that gets the task Done.

Here's the paper: https://arxiv.org/pdf/2510.01889

Claude Fable 5 and Opus 5 have no video input on the API, They read images, costs: a full-resolution image on Opus 5 runs up to 4,784 tokens, and at $5 per million input. Fable 5 is $10 per million, so the same image runs closer to 5 cents.

how agents actually use vision: A single browsing session or video breakdown burns dozens of screenshots. And every image you send stays in the conversation history and gets re-sent on every following turn.

workaround

I use Gemini 2.5 Flash-Lite through OpenRouter: $0.10 per million input tokens, $0.40 output, 1 million token context. It takes video too, mp4, mov, webm, even a public YouTube link, which Claude's API still doesn't.

Flash-lite samples video at roughly 1 frame per second, about 300 tokens per second of footage at default resolution. A 60-second clip runs about 18,000 tokens, a fifth of a cent. A 3-minute video, half a cent. An hour of YouTube at low resolution, about 4 cents. A single still image comes in around 258 tokens, roughly a thousand times cheaper than showing that same frame to Opus.

wiring

OpenRouter speaks the standard chat completions format, so this is one call:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -d '{
    "model": "google/gemini-2.5-flash-lite",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "describe this video shot by shot: timestamps, on-screen text, cuts, and what happens in the first 3 seconds"},
        {"type": "video_url", "video_url": {"url": "data:video/mp4;base64,..."}}
      ]
    }]
  }'

Wrap that in a script and tell Claude to call it whenever it needs to see something, passing a file path and a question. Claude hits something visual, calls the tool, flash-lite watches it, text comes back, Claude reasons over the text.

Ask for timestamps, on-screen text, cuts, framing, hook structure, not a generic "describe this video." A tighter question gets you a better result.

xAI's Memphis data centre runs on gas turbines that were never permitted, and they've been emitting nitrogen oxides and formaldehyde around the clock since the company started operating. Environmental lawyers and the NAACP are suing, and researchers now say the facility is likely the single biggest source of smog-forming pollution in the city.

on top of the air, there's the water. the site was supposed to shift off the memphis sand aquifer and onto a recycled wastewater plant, but construction on that plant stalled this year while the company focused on building out a second, bigger data center. so for now it's still pulling from the same aquifer that supplies the city's drinking water, and locals say more is being pumped out than gets replenished.

here's the full article - https: //time.com/7308925/elon-musk-memphis-ai-data-center/

Here are the new rules of Context Management as of fable 5 users.

Rules are being replaced by judgment. The old system prompt had lines like "default to writing no comments" and "never write multi-paragraph docstrings." Necessary early on, since older models would get it wrong without guardrails. Newer models handle the nuance fine. The replacement instruction is one line: write code that matches the surrounding comment density and idiom.

I've got CLAUDE.md files with a dozen formatting rules bolted on after some bad output six months ago. Half of them are probably fighting the model's judgment at this point instead of helping it.

Examples constrain more than they help. Counterintuitive, but giving Claude usage examples for a tool narrows its exploration space instead of expanding it. The better lever is interface design. Anthropic's Todo tool example: instead of showing sample calls, they constrained the status field to an enum (pending, in_progress, completed) and added one rule, only one item can be in_progress at a time. The schema teaches the behavior. No example needed.

Progressive disclosure beats upfront dumps. Code review and verification logic used to live in the main system prompt, because when it mattered, it mattered a lot. Now it's a separate skill Claude calls when relevant. Same logic applies to tools. Some are deferred-loading, meaning the agent has to search for the full tool definition before using it. Task tools work this way so they don't eat context budget until something actually needs them.

Changes how I think about skill files. A tree of smaller files that load on demand beats one CLAUDE.md trying to be the central repository for every edge case you've ever hit.

Stop repeating instructions. Earlier models paid more attention to the end of the context window, so instructions got duplicated in both the system prompt and the tool description as insurance. That duplication is gone now. Tool descriptions carry the instruction once.

Memory moved out of CLAUDE.md. The # hotkey for manually appending to CLAUDE.md is being replaced by auto-memory. Claude saves what's relevant to the work without you managing the file by hand.

Specs got richer. Plain markdown plan files still work, but Claude can now reference HTML artifacts, actual test suites, or a function from a different codebase to port. Rubrics are the interesting one, you hand Claude a rubric for "what good API design looks like" and it spins up verifier agents against that rubric instead of you manually reviewing taste.

For CLAUDE.md itself: keep it lightweight, spend the token budget on real gotchas in the codebase (the "types live in one monolithic file, nowhere else" kind of thing), skip anything Claude can infer from the file system on its own. Push the deep stuff into skills.

claude doctor (via /doctor in Claude Code) is built to catch exactly this, over-scoped skills and CLAUDE.md files that need trimming. Worth running before assuming your context setup is fine.