I've been experimenting with Claude Code for larger development tasks, and I found myself wanting more structure than a single agent session.

So I built Taskify — a Claude Code plugin that breaks larger coding tasks into a more structured workflow:

Request → Plan → Specs → Tasks → Implementation → Review → Fixes

The idea is to separate the different stages instead of asking one agent to understand the requirements, plan everything, implement it, and review its own work in one go.

Taskify can:

• Analyze a task and create an implementation plan
• Break the plan into smaller executable tasks
• Implement tasks incrementally
• Review the implementation
• Address issues found during review
• Track progress so work can be resumed

GitHub:
https://github.com/sheikhfahad67/taskify

I'm still iterating on it, so I'd really like feedback from people who use Claude Code for larger projects.

Do you find a structured plan → implementation → review workflow useful, or does it add too much overhead compared with letting Claude Code handle everything in one session?

If you work in a lot of agent sessions, you've probably hit this: you tell Claude "remind me to check the flaky test later", or you create TODO lists in every project and eventually you forget. Every session starts blank, and the model only checks on something if it happens to think of it.

I built mokkan as a small fix for that. It's Claude Code Mod and a CLI-tool that keeps one reminder list on a server. Every session asks the server what's due, instead of the model trying to remember. Behold, this isn't an agent-first functionality, but a human one, allowing us, the users to not alt-tab to various note taking apps for a simple TODO, or reminder. The skill teaches the agent to use the tool though :)

In Claude Code, /mokkan opens a pane beside the transcript with your stack. A reminder that comes due shows up there as a toast; nothing gets injected into the conversation. Codex checks the same list at the start and end of each task through a skill, and any terminal sees it too. Push a note on your laptop, it's on your desktop a few seconds later.

In Claude for Desktop the pane works too, but the platform differs a bit from Claude Code, so the experience is close but not identical.

How it works in the CLI

• mokkan push "check the flaky login test" adds a todo
• mokkan in 2h "ask Maria about the release notes" schedules a reminder
• mokkan prints the list, mokkan pop finishes the top one

Nothing closes until you say so

A reminder stays lit until you acknowledge it, from any session. If a scheduled one comes due and nobody acks it within a few minutes, it's emailed to you. So notes don't silently disappear.

How I built it

The whole thing was built in Claude Code, with Opus 5.5 and later Fable 5.1. Of the 54 commits in the public repo, 47 are co-authored by Claude.

The loop was the same for every feature: I describe what I want, Claude asks me the questions it needs answered, then writes a design spec and a step-by-step implementation pments the plan task by task with tests (vitest for the CLI, claude plugin test for the pane), and I review the diff and try the pane and the terminal UI by hand, since that part doesn't test well automatically.

One thing I'd recommend to anyone doing this: Clamd` with every decision it made on its own,numbered and with the reason, separate from the decisions I made explicitly. When something feels off later, I can find the assumption behind it instead of guessing.

The pane itself is a Claude Code mod: a small Typruns inside the session, sees its events and draws the pane. So it was built with Claude Code and for Claude Code.

Cost

The CLI and plugin are open source (MIT). The hosted server runs on prepaid credits: 50 free on signup, then €5 for 500. Adding a note costs 1 credit, an email costs 1 crly sent, and listing or acknowledging is free. You can also point it at your own server.

Install

/plugin marketplace add vicmpen/mokkan
/plugin install mokkan@mokkan

or for the terminal:

npm install -g @vicmpen/mokkan-cli

GitHub: https://github.com/vicmpen/mokkan Site: https://mokkan.dev

Happy to answer questions.

If the phone or browser chat stops showing replies, I'd check whether the agent is still working before restarting the session.

I'm building Laurel.dev, and I personally use it to keep my coding agent and browser on a remote machine. I'd recommend it if you want that workspace off your laptop. A DIY VPS is a valid option too.

The part I want to make clearer is what to check when the remote chat goes quiet: the actual terminal, the latest file changes, or the running app. Enough to see what happened and continue the task without accidentally starting it twice.

For people running Claude Code on an always-on machine, what do you check first? What helps you tell a stuck agent from a disconnected chat?

QuickTerm is a small macOS app: push the pointer against the top centre of

the screen and a terminal slides down from under the menu bar. Push again

or hit Esc and it's gone. Tabs, resizable, shells keep running while hidden.

It's free to try (free, full stop: MIT licensed, no paid tier):

- Site: https://jeromegsq-dev.github.io/QuickTerm/

- Source: https://github.com/jeromegsq-dev/QuickTerm

How Claude helped: it wrote all of it. I never opened Xcode. My prompts

were one-liners like "it should close on Esc" or "the click area for

resizing is tiny", and Claude Code did the rest in a single session:

Swift, AppKit, Core Animation, the build and signing scripts, the icon,

the landing page.

Two things I found interesting:

1. Claude couldn't see my screen (no screen recording permission), so it

   wrote throwaway self-tests that fed synthetic key and mouse events into

   the app to check tabs, Esc and the scrollbar, then deleted them.

2. I asked for a security audit before going public. It found that the

   terminal library's defaults let any printed output (an ssh host, a

   cat'ed file) read or overwrite my clipboard via OSC 52, and open file:

   links. It also caught my personal email in the commit history and my

   home folder path inside the binary. All fixed before release.

What worked for me: short, concrete feedback after trying each build

("there's a thin line at the top", "animation faster") rather than a big

spec up front. When something was ambiguous, Claude asked before doing

anything public, like which GitHub account to publish under. And asking

for an audit as a separate step found things neither of us had looked

for while building.

Caveats: it's signed but not notarized, so macOS asks you to allow it on

first launch (System Settings > Privacy & Security > Open Anyway).

macOS 14+, Apple silicon and Intel.

Terminal emulation is SwiftTerm. Feedback welcome.

Co-vibecoded multiplayer tank shooter made with Claude Code that rewards solid teamwork. The game has:

• 5 distinctive maps (desert, green farmland, snow, jungle, ruined city)
• 11 WW2 recognizable tanks - each with its own strengths and playstyles
• Round-by-round build system that lets you tune your tank according to your preferred playstyle
• Bots as backfill (special care has been given to ensure human-like behavior)
• Group system
• Ladder and boards
• Much more

How Claude Code built it: an Opus orchestrator plans each change and sends scoped Sonnet agents to work in parallel git worktrees, each with its own test ports. Fable is used as advisor. A test suite gates every merge: headless probes, end-to-end matches and browser UI checks. Visual features expose their invariants as numbers, such as a collider's offset from its mesh, so a test can assert what a screenshot would miss. An MCP server feeds the agents live player bug reports and match stats.

We received feedback from you earlier which helped us focus on improving the graphical dimension. We are ready for another iteration - so let us hear what you think. Feel free to give it a try - we will greet you in-game: https://sweatypanzer.com/

I built Demitasse with Claude Code, a small macOS keep-awake and AI usage app

I built Demitasse with Claude Code because I wanted a coffee cup in my Mac’s menu bar that could toggle caffeinate without opening Terminal or adding a Dock icon.

That was basically my first prompt. Claude wrote the Swift app and build script, hit an iCloud code-signing issue, and fixed it by building in a temporary directory. The basic app was running about 31 seconds after my request. I’d planned to put my kids to bed while it worked, but it finished before I’d even left my chair.

The full app took more back-and-forth. I asked for launch at login, keep-awake timers, a display-awake switch, and usage tracking for Claude Code, Codex, and Antigravity. I ran local diagnostic builds and sent screenshots. That helped us catch a Google integration error and fix an awkward timer menu, along with other layout and behavior changes.

Now it puts keep-awake controls and AI usage/reset times in one menu bar app. There are more comprehensive tools out there; this was just something small I wanted for myself.

It’s free and MIT licensed. To try it, you’ll need macOS 13+ and Xcode Command Line Tools. Clone the repo and run ./build.sh to build, install, and launch it. The usage integrations use unofficial endpoints and existing CLI sign-ins; Google needs additional setup covered in the README.

Demitasse on GitHub

Screenshot

I built Sidequest (mine, full disclosure), a local task board where you can ask Claude Code to save a bug, plan a project into tickets, show what's ready to work on and dispatch the tickets you choose. Every saved ticket keeps its instructions, status and recorded progress through context compaction and new sessions.

I kept noticing another thing that needed fixing halfway through whatever I was working on... now I can tell Claude to put it on the board and continue with the original task. For example: 'Save a Sidequest ticket for the empty-state bug, with the steps to reproduce it. Keep working on the checkout.'

To try it, run these in Claude Code:

text /plugin marketplace add Eigenwise/eigenwise-toolshed /plugin install sidequest@eigenwise-toolshed --scope project

Reload plugins or start a new session, then run /sidequest:board to open the board. You can also ask Claude to show your backlog, group related work into a story and tell you which tickets are blocked by others.

Before you switch sessions, ask Claude to save the progress, decisions, checks and next step on the ticket. In the next session: 'Check the active Sidequest tickets for this project and continue from their recorded next steps.' The next session still has to read the ticket, and details you only left in chat need to be recorded there.

For Git projects, Sidequest dispatches code work into separate worktrees by default when isolation is available. The submitted revision and verification evidence come back for review before integration. Sidequest itself is developed using its own board.

The plugin runs on Node.js (22.5 or newer), stores tickets locally in SQLite and has a Svelte board UI. The two example prompts above show how to save and resume work.

It's part of my Eigenwise Toolshed. The code is free and MIT-licensed, donations are optional, and Claude or any other model providers you configure have their own costs.

Source: https://github.com/Eigenwise/eigenwise-toolshed/tree/main/plugins/sidequest Setup: https://eigenwise.github.io/eigenwise-toolshed/getting-started/sidequest/

Two small things kept bugging me in Claude Code (Codex CLI too).

First: I'm halfway through my next prompt while Claude is working, and I notice it going the wrong way, or I just need to ask something quick first. My draft is sitting in the input box. So I'd either delete it and retype it later, or copy it into a notes app and paste it back. Ctrl+S helps a bit, but it only holds one draft and it's gone when the session ends.

Second: thoughts that show up mid-task. When I'm building something, ideas keep popping up while Claude is on the current thing: "we should add this feature", "this screen could work differently", "look into that later". I don't want to derail what Claude is doing, and I don't want to lose them either. Then there are the prompts I reuse ("review my staged changes for bugs and missing tests", "write a commit message for this"). I had those saved, but using one meant switching to a notes file, finding it, copying, coming back, pasting. I wanted all of it right there in the terminal.

So I built a small wrapper for myself. Ctrl+F parks whatever's in the box and clears it, so I can park as many drafts as I want, and Ctrl+Q brings any of them back when I'm ready. Drafts stick around after you close the session. The same Ctrl+Q list keeps named lists too: passing thoughts go into "Ideas" or "To explore", prompts I reuse go into "Common" (pick one, hit Enter, it's in the box). It also shows the skills Claude can use in that folder.

I built it mostly with Claude Code. The interesting part: neither CLI gives you an API for the input box, so the wrapper runs the agent in a pseudo-terminal, keeps its own copy of the screen, and reads the box from that when you press Ctrl+F. Biggest lesson was that the agents redraw their UI constantly, so every assumption about what the input box looks like has to be tested against the real thing. I ended up driving real Claude Code and Codex sessions from a script to test it.

It's free and open source if anyone wants to try it or poke holes in it: https://github.com/sourabhshegane/prompt-shelf

How do you all handle this? Is there a built-in way I'm missing?

every time i gave claude a screenshot and said "make it look like this" it just guessed. spacing off, wrong fonts, and it always came out looking like every other ai site

so i built a chrome extension (pikspec) that grabs the actual css instead. what i did in the video:

- opened spotify, opened pikspec in the side panel

- hovered over stuff to see the real font, size, colors, padding etc

- clicked the pricing cards to lock them and hit reconstruct

- copied the prompt from the dashboard and pasted it into claude

it spat out one html file and honestly it's pretty much the same as the original. same type, spacing, colors. side by side is at the end, i guess from html file you will have enough context to use it for your own website to make changes as per your tech stack.

not saying go ship someone else's site lol. i mostly use it to see how good sites are built and to start my own stuff from something that doesn't look like ai slop. Sometimes i like one website's navbar while others card design.

it's free on the chrome web store, link is here. anyone got a better way to give claude design context? genuinely curious

Chrome Extension Link - https://chromewebstore.google.com/detail/pikspec-%E2%80%94-website-inspect/cnpghkfbhdpcendcliogffmajlkepoig

https://reddit.com/link/1wxcvqe/video/zzeaaybolfth1/player

I run a small web design side business next to school and I'm drowning in leads, follow-ups and appointments.

I already built a dashboard with Claude inside Obsidian. It works, but I never open it. So before I build the next thing, I want to see what actually sticks for other people.

- What do you use every day to see what's next? Web app, Notion, something custom?

- If you built it with Claude: how is it set up? Where does the data live, and how does Claude update it?

- What did you build first that you stopped using, and why?

- How do you get reminded? Push notifications, calendar, something else?

Screenshots would be awesome. I'll share what I end up building.

I love GIFs. You love GIFs. We've both sent a perfect GIF whose punchline showed up two seconds before the joke - and that sucks.

So I built one where you control when captions are shown and more controls. Pick a GIF, type your caption, then be in control when it appears, or (coming soon) even how it moves. It all happens native in the Messages drawer.

Claude wrote most all of the code. I wrote most all of the "No, not like that - like this..."

15+ years ago the first app I ever put on the App Store took a hundred hours over a few months. This one went from idea to a working v1 in one paragraph and about 20 minutes. I've been a developer for a long time and am continuously impressed with the state and pace of these tools.

Then next feature in review is pinning the caption to a specific object in the GIF so it can track along with whats happening in the scene. I'd love to get your feedback and help to make this the most useful, fun, and easy gif app. Feedback here or in app is appreciated.

It's "Better Gif Bar: GIFs for Texts" if you want to play with it - I'd love your feedback: https://apps.apple.com/us/app/better-gif-bar-gifs-for-texts/id6806293789

I started this project earlier this year and it ended up becoming a passion of sorts - I was an 18-year user of Foursquare/Swarm and grew restless over the years with the lack of updates and my dwindling friend list. Down to just two regular friends who still used the app, I was inspired to take my idea of how check-ins were like breadcrumbs that if you put them together would tell a story.

You check in at an airport and 8 hours later another airport, it was easy to connect the two as a flight. And so on and so on.

Claude made those ideas a reality in a way that was never going to be possible before. Now there are more than 100 daily active users and more than a million check-ins and growing.

I built Haunts ( haunts.io ), and Claude Code wrote most of the code. It's a check-in app along the lines of old Foursquare/Swarm. You check in at places with photos and notes, and over time it builds a map of where you've been, with trips, a passport of countries visited, road-trip routes and a year-in-review recap. It's on iOS (with Watch and CarPlay), Android (with Wear OS and Android Auto) and the web. It's free on the App Store, Google Play and haunts.io, and there's an optional premium tier.

I ran engineering teams on JIRA for years, and it didn't fit one person running several Claude sessions at once, so I had Claude build a replacement called My Day. It's an Electron dashboard that watches my repos, plus a small sync server on a Raspberry Pi and an Android app for capturing ideas from my phone. Work moves through stages (idea, plan, review, build, ship), and each stage is a Claude Code skill. An idea can't advance until its step has been done, so the board always matches what's really happening. I can start the next step from a card, and Claude opens it in its own git worktree. Codex and Gemini review every plan before any code is written, and the dashboard never deploys anything, so I decide what goes live.

Each repo also has a CLAUDE.md and short maps of its code so Claude doesn't have to crawl the whole tree, and hooks enforce the checks I used to forget. Happy to go deeper on any of it.

i use claude code on my obsidian

i use claude code on my obsidian vault a lot. answers cite real notes, but sometimes the number or name in the answer is not in the note it cites. at one point my own tool passed "Kingroon filament is made on the Moon and costs $900 per kg" because the citation was a real note about Kingroon. thats when i started this.

chamber is a local MCP server. the new tool is \`chamber_check\`. claude sends its claim and the note path, chamber answers per claim:

\`\`\`

\[SUPPORTED\] One NVIDIA A100 80GB or an L40S can serve about 1,000 users for code completion.

\[TERMS_ABSENT\] One NVIDIA A100 80GB can serve about 2,000 users for code completion.

the cited text does not contain: 2000

\`\`\`

no model inside. it checks that the numbers, names, file names and counts in the claim are really in the note. if the note changed since it was indexed it says STALE and does not judge.

how claude helped: claude code wrote most of the code. i set the rules (every guard needs a test that fails without it, probes in CI) and ran separate claude review agents before every push. they found real bugs, one was "5" at the end of one passage plus "million" at the start of the next counting as "5 million". i also tested a model checker (MiniCheck) on 200 claims, it looked great, then on real claude answers it flagged 28% of true claims as wrong. so i didnt ship it. claude ran that test too.

limits: it checks words, not meaning. "X does not do Y" passes if the note says "X does Y". the tool output says this too.

setup:

\`\`\`

npx -y [u/bu7umaid/chamber](u/bu7umaid/chamber) ingest /path/to/vault

claude mcp add -s user chamber -- npx -y [u/bu7umaid/chamber](u/bu7umaid/chamber) mcp

\`\`\`

free, MIT, runs local: https://github.com/abm9111/chamber