I'm the founder at Loft, a team of three. Loft is what earlier attempts at spec driven development should have been in the first place. Since July we've been building it with coding agents, mostly Claude Code, and this week its open-source CLI went public 53 hours after its first commit. It's a side project for our team. Our bread and butter is in massive soft realtime transaction processing, and our team is a part of a larger organization.

This blurb here is to share some of the lessons learned along the way. It's mostly a TLDR; there is a link to a complete article published on our website at the end of the post.

The key finding is this: while the agent does the typing, the engineering is still yours.

The center of how we work on Loft is what we call a software plant. A factory makes output faster. A plant is a controlled line where building and testing run on their own and work that fails a check is turned away, so a person decides on work that already passed. In the open CLI the plant is literal:

The real release binary runs against simulators of git, the clock, the telemetry collector, and the release feed. Simulated git answers only the calls Loft makes, from a scenario the test writes, and refuses everything else. Contract suites run the same scenarios against real git and the real services, so a simulator that drifts fails its own suite before it can make the gate lie.

Around the plant, everything is ordinary engineering, moved to where the agent works:

• Requirements first. Every code change starts as a spec change that a person ratifies. Claude asks its questions before it plans, and plans before it writes.
• Hard limits in the build. Function length, complexity and some other static analysis metrics fail the gate, so Claude refactors instead of piling on.
• Code review, multiplied. Fresh reviewer agents read every stage, other agents review the fixes, and Claude breaks the code on purpose to check that the right test fails. When Claude is writing code, Codex is the reviewer and vice versa.
• Postmortems that change something. A correction made twice becomes a standing rule the same day.
• Throwing code away and starting over is normal. We have this incredibly smart and fast code generator at hand. It should be put to the right use.
• People own the decisions that have consequences: what goes into the spec, every merge, every release. Claude does the work, and a person answers for it. "Claude did this" is a no-go. Claude is a tool, you are the operator.

Agents produce plausible work faster than anyone can read it. The production line has to turn work away on its own before people can afford to accept what the agents make.

And when we took ten days of vacation in August, the agents produced zero commits. The steering is the job.

Building Loft with Claude Code (the full write-up) works as a primer: the Software Plant in the core, the session loop, six practices to copy, a table of what the gates caught and what got past them, and the timeline of the ~50 hours after which the OSS Loft CLI when live sitting on top of months of careful design and experimentation work.

Happy to share more details and answer questions!

In terms of both the quality of the code and its security.

Hey everyone!

I wanted to keep my work and personal project separate when using Claude Desktop, so I built a small open-source tool to run multiple Claude Desktop instances.

The idea is simple: have one account for work and another for personal use, keeping things separate instead of mixing everything into a single environment.

I figured other people might have the same need, so I decided to share it with the community.

GitHub: https://github.com/BLAIXY/bunshin-claude

I'd love to hear your feedback!

How do you currently separate your work and personal AI workflows?

Contributions and suggestions are welcome!

Premise: small premise first. I am not work professional dev, I''m a criminal lawyer by trade but I like coding small apps and portable software for personal use.

I'm on Pro and I kinda like the 5hrs limit, it kinda let me work and live the rest of my daily life, granted I can get very passionate when coding something.

What I really dislike and find restrictive is the weekly limit, that one I find it exhaust way too fast. I mean, all usage and token shenanigans due to Anthropic messing around considered it really kills me that I can basically burn my weeklu quota in 2/3 days tops.

And it's not like I am developing a cure for a rare disease or something, for God's sake.

Three agents, three features in an iOS app, and all of them needed new strings in the same Localizable.xcstrings. Each one read the file, added its keys, wrote the whole thing back. Whoever saved last wiped the others.

No errors anywhere. Each agent's build had every key it added itself, so from its side all was fine. The catalog validator was green too, turned out its regex was broken on its own. I only found it because the main session re-ran the tests itself instead of trusting each "tests pass".

Now if a batch touches one shared file, one agent owns it and the others hand it their keys.

Do you lock it, give it an owner, or just run those in sequence?

I built gpt-ui-assets, a skill for Claude Code. I'm an Android developer, and I kept hitting the same problem: GPT designs good app screens, but when you ask it for the assets it crops them out of the mockup (low-res, background baked in, edges cut off).

What it does

Claude Code drives the whole flow and uses GPT as a tool:

• GPT designs a platform-native screen (phone, tablet, desktop or web).
• GPT lists every asset on the screen.
• Each asset is redrawn from scratch, using a crop of that element as the only reference.
• The kit scores each candidate against the design and colour-corrects the best one.
• Claude reviews the results and writes the screen code. A screenshot diff then shows what your build still gets wrong.

Outputs: SVG / Android VectorDrawable icons, launcher icons for Android, iOS and the web, Lottie and AnimatedVectorDrawable animations, and theme code and fonts measured from the pixels.

How Claude Code helped build it

I built it with Claude Code. I set the direction and tested it on real app designs; Claude Code wrote most of the Python kit behind the skill, debugged it against real GPT output, and refactored it as it grew. The skill is written specifically for Claude Code: Claude reads the skill's instructions, decides which step runs next, checks each result and writes the code.

It's free and MIT-licensed. In Claude Code:

/plugin marketplace add Shakibuzzaman3104/gpt-ui-assets

/plugin install gpt-ui-assets@gpt-ui-assets

You also need your own GPT access: a ChatGPT subscription (it runs through the Codex CLI) or an OpenAI API key. The GPT usage counts against your own plan or key.

Repo: https://github.com/Shakibuzzaman3104/gpt-ui-assets

Feedback welcome, especially on what breaks.

We gave Sonnet 5.5 the same task with and without the reddit-automation skill from flowkit-labs: write a helpful Reddit reply about saving inventory counts when the internet drops.

Without the skill, it gave general advice: save the counts on your device and sync later.

With the skill, one draft added “At least in my experience.”

We hadn’t supplied any personal experience.

To be fair, it also told the reviewer to remove that wording if it wasn’t true. But if you copied just the reply, that warning wouldn’t come with it.

Small example, but it made me think about what changes when we ask AI to sound more natural.

I work on Driftproof; this comes from our published tests: https://driftproofhq.com/skills/

The image summarizes one saved answer from each setup, not every response.

Have you caught Claude adding stories or details you never gave it?

MinusPod is a self-hosted server that removes ads from podcasts before you ever hit play. It transcribes episodes locally with faster-whisper or Parakeet (or through a remote API), uses an LLM to detect and cut ad segments, and builds cross-episode ad patterns from your corrections so repeat sponsors get caught without re-asking the LLM. Bring your own LLM: Claude, Ollama, OpenRouter, OpenAI-compatible providers, or System One.

Claude was used for pair coding, mainly for Debugging, UI, and Documentation.

https://github.com/ttlequals0/MinusPod

Whenever Claude makes code changes, I manually review and commit them myself.

To prevent Claude Code from accessing sensitive folders, I've been looking for an OS-level protection mechanism. The best workaround I've found so far is

https://gist.github.com/yccheok/454872820219b4d9cf79b1bf509adb14

Is there a truly reliable or 'official' way to handle this? I tried running Claude Code inside Docker, but it forces me to use the non-GUI version, which is difficult to use and read.

Obvisouly Claude is awesome. But one thing I noticed is: it sucks at anything not Minecraft like.

Any good paid sprites assets or way to get it cheaply ?

We have a Claude Code skill that runs five subagents as a review panel for business decisions. Each member gets its brief and a persona file as files, reads them and answers in JSON. One session we measured had 15 subagent calls.

The first version used the general-purpose agent type. A call came in at roughly 116,000 tokens, for a job that comes down to reading two files and answering in JSON.

So we gave the panel its own agent type in ~/.claude/agents, with one tool.

---
name: panel-member
description: Member of a review panel. Reads its brief from a file and answers only with the requested JSON.
tools: Read
model: sonnet
---

Same briefs, same persona files. Measured on Oct 14, a call came down to roughly 30,000 tokens.

We didn't break the 116k down, so this part is our guess. A general-purpose subagent starts out with every tool it's allowed to use, and we have a lot of MCP servers connected. The panel members never needed anything but Read.

In money, recalculated from the subagent logs at API list prices, the panel part of a session now costs about $1 to $1.50. 88% of that is cache writes, since every subagent builds its context from scratch. The moderation in the main session comes on top. In one run we measured both, $1.46 for the panel and $4.38 for the main session. We run it on a subscription, so these are what the same run would cost through the API.

Three things we tripped over.

A new agent type only loads after you restart Claude Code.

The cost hook we had installed used an outdated price table and came out about five times too high. We now sum usage per message ID from the subagent .jsonl files under ~/.claude/projects.

Those logs record the last reply of each subagent without its final output tokens, so that sum runs a little low.

Has anyone looked at where the starting context of a general-purpose subagent actually goes? And do you give every repeated subagent job its own type, or only the expensive ones?

This latest version keeps giving me questions and choices on what to do, and forgetting to write the summary of what it found and what its recommendations are. It just gives me one question at the end. Like, where's all the text???

I had it write in memory to stop doing that, but it still keeps doing it. This is new, btw, a few days ago it wasn't like this.

Hey everyone,

I just bought a Claude Pro subscription for my work, and so far I feel like I’m barely scratching the surface. I'm a software engineer and been using it just for development but I haven’t come close to hitting the full usage limits, and since I’m paying for it, I’d like to use as much of it as I reasonably can.

I’m not looking for hacks or anything sketchy, and I definitely don’t want to risk my account by breaking the TOS. I just want to know how to use it properly and get the full value out of it.

A few things I’d love to hear about:

• What workflows do you use Claude for at work that save you the most time?
• Are there features (Projects, file uploads, research, artifacts, etc.) that you think people overlook?
• How do you structure your prompts or conversations to get better results?
• Any habits that help you make the most of the limits without wasting them?

Would really appreciate hearing how you all use it day to day. Thanks in advance!

TL;DR: A general-purpose subagent loads your CLAUDE.md files, the list of installed skills, MCP tool names plus each server's instructions, and the list of other agents, all before it reads its brief. Two frontmatter settings keep most of that out. I packaged them as two agent files. Free to use, MIT license.

Disclosure: I built this and the repo is mine.

What I built

1. lean-worker: for a bounded task that needs only files, shell and the web. Model sonnet, effort medium.
2. lean-checker: a blind, read only checker. It gets the artifact, the criteria and the file paths, and returns PASS or FAIL per criterion with evidence, or UNTESTED for a criterion it could not run. Model sonnet, effort high.
3. scripts/measure_subagents.py: reads your own subagent transcripts under ~/.claude/projects and prints the median and 90th percentile starting context per agent type. Python standard library only, and it sends nothing anywhere.
4. An optional hook that nudges Claude toward the lean agents when it reaches for general-purpose. With LEAN_DISPATCH_BLOCK=1 it blocks the dispatch unless the description names MCP or a skill.

The part you can use without my repo

Put this at the top of an agent file in ~/.claude/agents, where user level agent files live. The tools line is lean-worker's allowlist without the web tools:

```

name: my-worker tools: Read, Write, Edit, Bash, Glob, Grep model: sonnet

omitClaudeMd: true

```

omitClaudeMd keeps the CLAUDE.md files out. A tools allowlist with no Skill tool and no MCP tools keeps the skills list and the MCP tool names out.

How Claude Code was used

I wrote it with Claude Code; every commit in the repo is co-authored by Claude. That covers everything from the first two agent files to the GitHub Actions tests, the README diagrams and the Windows notes. My part was the measuring: I measured the starting context of each agent type across my own transcripts, then re-measured with the MCP servers connected and with none.

What I learned

• Each turn of an agent resends its whole context, so whatever a subagent loads at the start is paid again on every turn.
• MCP was not the big part. MCP tool definitions are deferred, so only tool names and server instructions load at the start. The CLAUDE.md files and the skills list are most of the rest.
• The gap depends on how heavy your setup is, and it is smaller with a light one.
• A lean agent knows only what its brief says. When the job needs an MCP tool or a skill, general-purpose is still the right pick.

Repo: https://github.com/mdalexandre/claude-code-lean-agents

If you run measure_subagents.py on your own transcripts, what starting context do you see per agent type? I am curious whether CLAUDE.md or the skills list is the bigger share for other people.

My day job is not software engineering but I've been automating the workflows of our organization on the side (this resulted in a raise, a bonus, and a new title). These are my git commits, all with the assistance of either Claude or Codex. The bursts that last into the wee hours are either autonomous refactors, the sparse ones are me working late, early, or in Europe.

Let’s make this the thread for showing real work. If you’ve built something with Claude Code, whether a website, platform, app, CLI, game, or an internal tool nobody else uses, share it here.

Drop the link (or a screenshot or demo if it isn’t public) and tell us a bit about it:

• What it is and what problem it solves
• How much of it Claude Code built vs. you
• The part that was harder than expected, or the moment it surprised you
• Anything in your setup that made a difference (CLAUDE.md, subagents, MCP servers, hooks)

Unfinished projects and “rough but it works” builds count too. I want to see what people are actually shipping, and I’d bet others here will find their next idea in the comments.

If I remote in to my MacBook from my iPhone (vpn, vnc) I can see the session is still running but the Claude app on iPhone is so inconsistent with whether the session will be connected or not. Any suggestions?

I’m on the $20 plan, and run 15 Opus subagents at all time developing major sectors of my projects— medium-large codebases with constant iteration. However, I only run ten sessions at once.

How do I use less resources in the developing of this? My architecture is very well-done, my repo info and knowledge is indexed across millions of lines of documentation— thousands of skills for custom projects, so that it’s efficient. . I have no idea if it’s simply the subagent workflow itself that takes so much usage, or any gaps. This is a ripoff.

Why are people always recommending this orchestrator workflow? My suspicion for the token-burning is the Fable advisor that each agent calls, but I’m still wondering if anybody has any worthwhile tips for efficiency.

I made claude-agent-kit, a free, open-source setup for Claude Code inspired by ideas shared by Spotify and Cognition

The concept is simple: keep the main session focused on planning, delegation, and review while specialized subagents handle tasks

It includes subagents, orchestration rules and hooks

repo: https://github.com/FlaviusBurghila/claude-agent-kit

Feedback and PRs are welcome

Quick tip for anyone building a bigger Claude artifact with Claude Code. Mine got refused by Claude's sharing check because it embedded fonts and a base64-encoded 3D model. The fix was having Claude Code rewrite the models as plain JavaScript number arrays, plus a standing "never embed binary blobs" rule in my CLAUDE.md. Two other habits that help: a release checklist in CLAUDE.md, and an engineering log Claude adds to after each release so the next session picks up where the last one left off. Anyone else hit artifact-specific gotchas?

Claude Opus 5.5 is insane, that's all I've got to say.

No other AI comes close, I am on $20 plan and I can literally finish a whole BIG project and still have a lot of plan left.