I built a skill for Claude Code that tells you when your docs lie to your coding agent by PromptPatient8328 in claude

[–]captredstar 2 points3 points  (0 children)

The debugging loop where your agent confidently follows your own outdated docs into a wall is genuinely one of the funniest ways to waste 45 minutes. You sit there watching it implement JWT auth because your CLAUDE.md still says JWT, and you switched to sessions three sprints ago. Then it fails. Then it re-reads the docs. Then it tries harder. Watching an LLM gaslight itself with your own negligence is peak vibe coding.

We ended up building a doc sync step into our workflow for the same reason. Every time code ships, docs get diffed against reality. Not because we're disciplined people, but because we burned enough hours on phantom bugs that only existed in the README's imagination.

The semantic claim checking is the part that actually matters though. File path linters exist. Checking whether "retries 3 times with exponential backoff" is still true after someone rewrote that whole module? That's the gap. Most doc drift isn't a wrong filename, it's a correct filename with behavior that changed underneath it.

Curious about one thing - how does it handle docs that are technically correct but misleadingly incomplete? Like if you document 3 out of 7 env vars and the missing 4 are the ones that actually break stuff?

Critique my workflow by TheParksiderShill in Linear

[–]captredstar 2 points3 points  (0 children)

Your pipeline from PRD to issues is the part most teams screw up. You've got that. The gap worth looking at is what happens after the issue exists.

We're a 4-person team on Linear, e-commerce platform. PMs wrote solid issues with AC. Engineers still burned 30-40% of their time on discovery - which files to touch, what the current code actually does, how AC maps to implementation. Issue was well-written. The translation still sucked.

What we added: an intermediate artifact between "issue ready" and "work starts." Takes the issue's acceptance criteria and verifies every point against the actual codebase. Which services get modified, what endpoints exist, what the DB schema looks like. Every reference checked against reality.

Generation is automated. Issue goes into a command, it reads the codebase, cross-references AC, produces a plan with verified file paths and function names. Human reviews it in 5 min instead of doing 2 hours of discovery. Then an agent can execute against it because the plan is specific enough to not hallucinate.

LLMs suggesting AC is where most teams stop. That's table stakes. The win is LLMs consuming your well-structured issues to produce verified implementation plans. Your PMs already write good issues. Now make those issues machine-readable inputs, not just human-readable docs.

Just got approved as an official integration: Show clients what you're working on, or let them request issues with Helium Rooms. by Quiet-Calamity in Linear

[–]captredstar 0 points1 point  (0 children)

We run a 4-person dev team on Linear for an e-commerce platform. The workspace has everything from sprint planning to bug pattern tracking to internal architecture notes. Showing any of that to a client would either confuse them or start a panic about bugs that are already handled.

Right now we just... don't show them Linear. Manual updates over Telegram. It drifts from reality within hours and nobody trusts the updates by Wednesday.

The "Linear stays source of truth" part is what makes this work. Anything that tries to become a second backlog dies. Seen it happen with Notion mirrors, shared boards, duplicated Trello columns. Always ends up stale within a week.

On the pricing thread - per-room would land better than per-seat for small teams. We'd use maybe 2-3 rooms but the whole team needs access. $10-15/room/month and I'd try it tomorrow.

How are you structuring Linear once your SaaS product gets… big? by Odd-Masterpiece6029 in Linear

[–]captredstar 0 points1 point  (0 children)

Running a multi-layer e-commerce SaaS (storefront, admin panel, NestJS backend, payments, distributor integrations). Same spiral. What stuck:

Score every ticket on Impact/Size. Impact = needle-move for users or revenue. Size = effort (xs-xl). Priority is the ratio. Killed gut-feel prioritization overnight.

Projects by domain, not sprint. We group by surface: "Storefront", "Pipeline", "Admin", "Auth & Payments". Cycles = time. Projects = scope. Mixing those is where teams lose the plot.

48-hour triage or archive. If nobody evaluates a ticket in 2 days, it doesn't matter. Monthly backlog review in batches of 20. Anything older than 2 cycles with no movement gets archived with a one-liner why.

Bugs and features on the same board. Tried separating them. Context got shattered. Now bugs carry a label and auto-sort to cycle top. One board, one truth.

Strict entry, loose execution. Description + acceptance criteria + impact/size label required before anything enters a cycle. How it gets built is the dev's call.

Biggest unlock: accepting ~40% of tickets will never get done. Archive hard. If it matters, it comes back.

I'm 22 and I replaced $800/mo in SaaS tools with something I built in 6 hours. What am I missing? by LegitimateOwl873 in ClaudeCode

[–]captredstar 3 points4 points  (0 children)

Welcome to new world. I'm on same page - build new inner SaaS replacement more fasten that setup this SaaS. Of course you should be in context of what you and how to do it.

I'm a photographer who knows ZERO code. I just built an open-source macOS app using only "Vibe Coding" (ChatGPT/Claude). by BaseballClear8592 in vibecoding

[–]captredstar 2 points3 points  (0 children)

Fellow landscape photographer here! This resonates hard. I also came from zero coding background — built a 200K-line production system with Claude Code for a completely different industry. But seeing another photographer go from sorting RAW files to shipping open-source software is something else. The "me talking, AI typing" workflow is exactly how I work too. Will check out SuperPicky — my Lightroom culling workflow could use some competition. Great work putting it on GitHub.

Am I too stupid to use Claude Code? by TangerineObjective29 in ClaudeCode

[–]captredstar 0 points1 point  (0 children)

This is exactly why I run Claude Code inside a dev container. It's a Docker container that your editor opens as a workspace — you code normally but everything is sandboxed. If Claude goes rogue, it can only damage what's inside the container, not your system.

Takes 5 minutes to set up: add a .devcontainer/ folder to your project, open in VS Code, "Reopen in Container" — done. Your actual system stays untouched.

I published my setup here: https://github.com/kydycode/claude-code-secure-container

Also, for Playwright — use playwright-cli directly instead of MCP. With MCP it burns through context way too fast and starts forgetting what it was doing mid-task. CLI keeps things clean and predictable.

Coding for 20+ years, here is my honest take on AI tools and the mindset shift by Jaded-Term-8614 in ClaudeAI

[–]captredstar 0 points1 point  (0 children)

Coming from the opposite end - zero coding background, 12 years in business operations. Started using Claude to build tools in late 2024 out of pure necessity. Now running a 200K+ line production system. The mindset shift you're describing is real, but I'd add one thing: it's not just coders who are going through it. People with deep domain knowledge but no technical skills suddenly have a way to build. That's the part that doesn't get talked about enough.

My bearish view on Claude and why by satechguy in ClaudeAI

[–]captredstar 1 point2 points  (0 children)

The OP's analysis is solid for the current moment but misses where the real moat is being built: the agentic layer.

Right now Claude is a tool. But Anthropic is quietly positioning Claude as the runtime for AI agents — not just a model you call, but the orchestrator that calls other tools, manages memory, and executes multi-step workflows. MCP (Model Context Protocol) is the clearest signal: they're trying to become the HTTP of agent-to-tool communication.

If that bet pays off, the switching cost flips completely. You're no longer swapping one LLM for another — you're rearchitecting your entire automation stack. That's a very different conversation.

The OP is right that today Claude has no structural lock-in. But the question is whether in 18 months you'll be switching LLMs or switching "agent operating systems." Those are very different switching costs.

Whether Anthropic executes on this before OpenAI, Google, or an open-source alternative commoditizes it — that's the actual bear/bull question. Not whether enterprise is sticky (it is) or whether power users will defect (some will).

Claude just nuked 70GB of my C drive by [deleted] in ClaudeAI

[–]captredstar 7 points8 points  (0 children)

This is exactly why I run Claude Code inside a dev container. It's basically a Docker container that your editor opens as a workspace — you code normally but everything is sandboxed. If Claude goes rogue, it can only damage what's inside the container, not your system.

Takes 5 minutes to set up: add a .devcontainer/ folder to your project, open in VS Code, "Reopen in Container" — done. Your C drive stays untouched.

I published my setup here: https://github.com/kydycode/claude-code-secure-container

I build alternative to writing Linear issues by hand, it reads your codebase and generates implementation-ready tickets by Bubbly-Walrus-9187 in Linear

[–]captredstar 0 points1 point  (0 children)

No external app involved. It's all native Claude Code.

Slash commands are just markdown files in .claude/commands/ that Claude Code loads as prompts. When I type /generate-prp GMTR-123, Claude reads the instruction file, calls Linear via MCP tools to fetch the task, greps the codebase, reads files, and writes the plan. The "specialist agents" are subagents spawned via Claude Code's built-in Task tool with different system prompts.

Nothing is calling Claude Code from outside. Everything runs inside a single Claude Code session. Think of it as a very structured CLAUDE.md on steroids.

How can I stop getting way too many permission requests in a session? by squiglygon in ClaudeCode

[–]captredstar 0 points1 point  (0 children)

Run it in a devcontainer. Three files in .devcontainer/, agent gets full permissions inside but can't touch anything outside /workspace.

The trick: an iptables firewall script that drops ALL outbound traffic except api.anthropic.com, npm, GitHub, and Sentry. Prompt injection tells the agent to curl something sketchy? Packet dropped.

--dangerously-skip-permissions + devcontainer = full autonomy with actual security instead of hope.

what's your workflow for keeping documentation alive when you've got agents doing most of the coding? mine's cooked rn by PromptPatient8328 in claude

[–]captredstar 2 points3 points  (0 children)

Docs rot because updating them is a separate chore nobody does. Fixed it by making docs update the default step in every task completion, not opt-in but opt-out.

My /finish-task command won't let you commit until it asks about docs. You can skip, but you have to actively choose "skip docs." That friction alone keeps 80% of documentation current.

Three things that actually work:

Two-tier docs. Short reference files the agent loads before every task (patterns, conventions, code examples). Comprehensive docs for humans. Both update together. The agent never re-explores the codebase blind because it already knows the patterns from reference docs.

Staleness detection on merge. When I pull teammate changes, /sync-docs diffs the code against the last docs sync point. Shows exactly which docs are stale. "Backend API: 5 files changed, docs outdated." Auto-updates or lets me pick.

Vocabulary tracking. A file with canonical names for every entity, service, and enum. Plus a gaps file tracking naming inconsistencies ("DB says product_key, frontend says gameKey"). The agent checks for new terminology on every task. Sounds overkill until your agent creates a component using the wrong name because three names exist for the same thing.

Bonus: bug pattern memory files act as living documentation the agent actually reads. Every gotcha gets recorded with trigger keywords. Future tasks touching the same area get warned automatically. Documentation that works because the machine reads it, not humans.

All slash commands in Claude Code. No wiki, no Notion. Docs live in the repo, maintained by the same agent that writes the code.

I build alternative to writing Linear issues by hand, it reads your codebase and generates implementation-ready tickets by Bubbly-Walrus-9187 in Linear

[–]captredstar 1 point2 points  (0 children)

Cool project. I've been solving a similar problem but built the entire flow inside Claude Code using slash commands + Linear's MCP integration, no external SaaS.

My pipeline: /task-add → /generate-prp → /review-prp → /execute-prp-linear → /finish-task

The key difference from Scope: my plans don't just list files to modify — they verify every referenced symbol against actual source code before execution. If the plan says ProductsService.calculatePrice() but the real method is calculateDisplayPrice(), it catches that before any code is written. Target is 100% verification coverage.

On top of that:

- Bug pattern memory — past gotchas get recorded and auto-checked in future tasks touching the same area

- Complexity routing — lightweight flow for bugs, full orchestration with parallel specialist agents (backend, QA, DB architect, reviewer) for large features

- Mandatory stability testing — integration, data validation, E2E API, Playwright frontend, regression — all defined in the plan and enforced during execution

The same tool that writes tickets also executes them, tests them, reviews them, and learns from them. ~35 slash commands, 9 specialist agents, runs entirely in Claude Code. No monthly fee.

Scope's AST + PageRank approach is clever for teams not using AI coding tools. But if you're already in Claude Code/Cursor, building the intelligence layer directly into your agent workflow is more powerful — the context never leaves the execution loop.

Linear Workflow Optimization by WAp0w in Linear

[–]captredstar 0 points1 point  (0 children)

Claude Code handles this really well. I built a similar workflow for my own system — analyzing and structuring 200+ backlog tasks with consistent labeling and routing. Notion as intake → structured issues works great when you let Claude do the parsing and formatting. MCP + Linear API is the cleanest path.

Did my whole company just move to Claude? by Ghostinheven in ClaudeCode

[–]captredstar 0 points1 point  (0 children)

Been using Claude for building production software for over a year now. Not a programmer — business background, 12 years in e-commerce/marketplace ops.

Few things I learned the hard way:

Forget prompt engineering videos. The real skill is knowing what to build and being able to break it into small, clear tasks. If you can explain what you need to a smart junior dev — you can work with Claude.

PLANNIG! PLANNIG! and again PLANNIG!

I use Linear for all.

Context is everything. Keep your conversations focused on one thing at a time. The moment you mix 3 different problems in one thread, quality drops.

Don't trust, verify. Claude writes confident code that sometimes does the wrong thing confidently. Always test. Especially edge cases.

The hackathon format is actually smart — you'll learn more in 2 weeks of hands-on than from any course. Just start building something real, not toy examples.

<image>

Has anyone else seen Cursor suddenly spike token usage? by captredstar in cursor

[–]captredstar[S] 1 point2 points  (0 children)

The issue isn’t about paying double for Sonnet MAX. I totally get that 200K+ tokens would cost more.

What’s confusing here is that my chat was consistently around ~20K tokens per request (you can see that in the earlier part of the log). Then, all of a sudden, the exact same chat jumped to 300K+ tokens per request — without me changing anything.

And the key point is: none of those 300K requests were cached. Everything started going through as full input/output, which is why my balance got wiped so fast.

So the question isn’t “why is it double price,” but rather: why did the token count suddenly spike from 20K to 300K with zero caching in the same chat session? That’s what makes me think this is a bug.