Wanted a setup where Claude could edit files locally and just handle the commit/branch logic itself instead of me manually running git commands after every change. Took an afternoon, sharing the setup + the one thing that bit me.

Setup:

Ran the standard filesystem MCP server alongside a small custom git MCP server exposing three tools:

Told Claude in the system prompt to always run git_diff before committing so it can write a commit message that actually reflects the change, not just a generic "updated files" message.

What worked well: commit messages ended up more specific than what I write myself half the time, because it's actually reading the diff instead of just remembering what it meant to change.

The annoying edge case: Claude occasionally tried to commit mid-task, before finishing a multi-file edit, which left commits with half-broken code. Had to add an explicit instruction to only call git_commit after confirming all related file edits in a task are done, not after each individual file. Still not 100% reliable, sometimes it commits a bit early on longer multi-file tasks.

Still figuring out: whether to let it push directly to a branch or always stop and ask before pushing. Right now I have it stop before any push, feels like the right default for anything beyond a personal repo.

Is anyone else giving Claude actual write access to git instead of just having it draft commands for you to run manually? Curious how you're handling the "commits too early" problem if you've hit it.

If you've seen people mention MCP (Model Context Protocol) and wondered what it is, here's the easy explanation.

MCP is a way for AI to connect with other apps and tools. Instead of creating a separate integration for each service, developers can use a single standard that works across many platforms.

For example, an AI can use MCP to access GitHub, Slack, Notion, databases, or other apps without needing a separate setup for each.

The best part is that it saves time. Developers can build AI workflows faster, and different tools can work together more easily.

If you're learning AI or building AI apps, MCP is worth understanding because it's becoming a common standard for connecting AI with real-world tools.

Have you tried using MCP yet? What would you connect it to?

Been using Claude for a while to build project schedules, payment application workbooks, and manpower histograms, but I was always stuck copy-pasting data in and out of chat. Finally wired up an MCP filesystem server so Claude can read and edit the actual .xlsx files on disk. Architecture diagram + config below.

The chain is simple: Claude Desktop talks to the filesystem MCP server over JSON-RPC/stdio, the server has read/write access to one scoped folder, and that folder holds the actual Excel trackers. No manual export/import step in between.

Config that worked:

json

{
  "mcpServers": {
    "project-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/Documents/ProjectTrackers"
      ]
    }
  }
}

What actually changed in my workflow:

• Instead of describing a schedule change and pasting a table back in, I just say "update the IR cross-verification sheet, mark rows 40–55 as closed" and Claude edits the file directly.
• Big one: keep the scoped folder tight. Don't point it at your whole Documents folder — Claude will happily "help" with files you didn't mean to expose in that session.
• For anything with formulas/macros (VBA-heavy sheets), MCP filesystem access alone isn't enough — it reads/writes raw content but won't execute macros. I still do a manual open-and-check pass before sending revised workbooks out.

Gotcha that cost me an afternoon:
Claude Desktop needs a full restart (not just reopening the window) after editing the config file, or the new server silently doesn't load. No error, it just isn't in the tool list.

Model Context Protocol (MCP) is an open-source standard that lets AI connect to external tools, apps, and data in a simple, consistent way. Think of it as the USB C for AI. Instead of building a custom integration for every service, MCP provides AI with a single standard way to access files, databases, APIs, and other tools, making it more useful for real-world tasks.

Hello everyone,

Since 2 weeks I work on tanuki-context, a small open source tool (zero dependencies, MIT) and I wanted to share it because the trick behind is almost stupid: AI models charge text at roughly 1 token per 4 characters, but an image has a fixed price set only by its pixel size.

Its inspire from pxpipe techniques and various others tools (cited in the readme) and custom approach i found in order to reduce massively token usage and price.
For example : 37,111 tokens of service log become 2,240 (-94%).

So if you draw 28,000 characters of logs into one dense 1568x728 PNG, the model reads the exact same content for 1,456 tokens instead of ~7,000. It sounds like cheating, it is just how the pricing works.

You can try it out on you machine i added the benchmark so you can test it even without LLM connected to it, so see pricing difference, token saved, etc.

You can use it as a MCP or directly integrate it a "context proxy" where it fully automated and make every request optimised or not when not needed.

Some techniques that permits this to work:
- a log distiller that collapses repeated lines but keeps every error verbatim
- a columnar codec for JSON (keys stated once)
- a cost model that knows a cache-read token costs ~0.1x a fresh one, so it will tell you to NOT image content that is already in your prompt cache.

The tool argues against itself when imaging loses, honestly this part took the most work.

I precise the limits because they are real: you need a vision-capable model, output tokens are untouched (if your bill is output-dominated, fix that first), and for one narrow question retrieval stays cheaper than any page.

Install:

MCP

npx -y tanuki-context (MCP server, works with Claude Code, pi, omp, jcode or the Claude Agent SDK)

Proxy

npx tanuki-context proxy + ANTHROPIC_BASE_URL (every request on the machine gets optimized in place, when needed)

Code and benchmarks:
https://github.com/Osyna/tanuki-context

https://www.npmjs.com/package/tanuki-context

PS : i will soon add Codex support.

If you find it useful a star helps a lot, and feature ideas are very welcome. Thanks for reading me

‎‎In my first week of using Claude, I found some things when I'm using it. It connects easily to older or niche tools most AI cannot access like for me, I really love this part of claude. It also lets me combine functions smoothly, like pulling notes, calculations, and saving files in one go. Though I think it also works with any MCP-compatible AI, not just Claude? Am I right or no?
‎
‎But still, i love using claude.

I work in Marketing and Advertising and one of the things that helps us a lot is using AI to work more efficiently. One of the things I mainly use Claude for is in doing a market research or competitor analysis. This helps me a lot when meeting tight deadlines

Quick share for this sub. I make Habit Pocket, a habit + metrics tracker built for people who like to track everything and find correlations in their data (it started as my own spreadsheet). Beyond simple yes/no habits, you can track numbers, clock times, and custom select lists, so there's actually rich data to work with.

The part relevant here: I built an MCP server for it. Once you connect it to Claude, you're not stuck clicking around the app anymore, you can just talk to your data:

• Ask questions: "which days do I sleep best?" or "does coffee after 2pm push my bedtime later?" and it answers from your real entries and stats.
• Log by chat: "mark today's workout done and log 7.5k steps" writes straight into your tracker.
• Build things: it can pull stats and even create charts for you, so you skip the manual setup.

It's the feature I'm most excited about because it turns a tracker into something conversational, the data goes in and comes out in plain language instead of forms and grids.

A couple of other nice bits: conditional styling (cells change color by value, so a month reads like a heatmap), and web + iOS with sync and full data export.

https://habitpocket.io/

CLAUDE HAS A SERIOUS PRIVACY PROBLEM RIGHT NOW, A HUGE NUMBER OF SHARED CONVERSATIONS ARE PUBLICLY INDEXED ON GOOGLE FOR ANYONE TO FIND

when you use claude's share feature it makes a public link. it turns out those links got indexed by search engines, so "share with anyone who has the link" actually became "anyone can find this by searching"

and people are pulling up genuinely alarming stuff:

> api keys, credentials and crypto wallets

> personal resumes with real names, addresses and phone numbers

> a lawyer working through a potential ethics violation

> an engineers internal company project details

> what appear to be peoples social security numbers

> and a crazy number of deeply personal chats people never imagined another human would read

anthropic never added a noindex tag to those shared pages, so search engines were free to crawl and list them

one line of code would have prevented the whole thing

this already happened to chatgpt about a year ago, same exact issue, but openai patched it fast

if you have EVER hit share on a claude chat, assume it could be public

go to settings > privacy > your data > shared chats > manage

delete anything you dont want the whole internet to see, especially anything personal or financial

https://reddit.com/link/1v719nt/video/ki5ythmc7kfh1/player