• The guide explains how to convert a spare Mac into an always-on environment fully controlled by Claude Code, enabling "computer use" (screenshots, clicking, dragging) safely.
• Running Claude Code with the --dangerously-skip-permissions flag on a primary machine carries inherent risk; isolating it on a dedicated device with no sensitive data mitigates these issues.
• Using actual Mac hardware rather than a container or VM provides the agent access to macOS-exclusive applications and full graphical computer use capabilities (e.g., driving Unity for game development).
• The setup enables remote control of the agent from a phone via the Claude app or over SSH from a primary Mac.

Hacker News Discussion

• Alternative Sandbox Environments: A prominent subset of users argued that dedicated physical hardware is largely unnecessary for agent isolation unless specific graphics/Unity workflows are needed. Commenters shared alternative workflows, such as utilizing libvirt to spin up disposable Linux graphical desktops with Full Root, utilizing simple unprivileged accounts (useradd agent), or using lightweight cross-platform engines like smolvm for egress filtering.
• Mobile Use Cases and "Vibe Coding": Several power users highlighted that they now bypass traditional IDEs entirely, relying on Claude Code running 24/7 on remote nodes to queue up background analytical workflows, conduct fuzzing protocols, or triage real-time on-call alerts (e.g., checking Datadog/Cloud logs) directly from their phones during weekend transits.
• Context Window and Token Expense: Users engaged in long-running jobs noted a major limitation: keeping active sessions open for hours results in frequent cache misses on large codebases (500k+ tokens), causing token consumption to escalate quickly. Deleting or recycling sessions periodically is recommended by Anthropic to manage costs.
• Criticism of Scripted/AI-Generated Content: A few commenters expressed fatigue over the setup guide itself, complaining that the underlying shell scripts felt bloated and heavily AI-generated, making the logic overly dense to review or maintain.

• The author, a designer at Jane Street, now primarily uses Claude Code rather than Figma to design and prototype new features.
• Instead of creating traditional spec documents, Figma mockups, and proposals, the new workflow involves writing a problem description, opening an editor, and using Claude to build an interactive prototype inside the actual codebase.
• Building high-fidelity prototypes directly in the medium (e.g., using OCaml and Bonsai at Jane Street) eliminates intermediary artifacts and allows the author to quickly iterate on minute details like keyboard shortcuts, copy, and button refinement.
• This approach makes evaluating concepts much easier for stakeholders, as they can interact with a live tool rather than static frames, which is particularly valuable when testing the feasibility of complex features like internal LLM integration.
• A key shift in their model happened over the course of a few months as improved models, growing prompting familiarity, and proper scoping allowed for handling large-scale diffs (exceeding 2,000 lines).
• A major workflow challenge is how engineering teammates handle code reviews for fully baked features; the current solution treats the prototypes like "code mockups" that engineers can iterate on or reference to write the official production code.
• The author expresses concern that relying on Claude might stifle fluid, out-of-the-box creativity, locking them into an incremental, iterative mindset constrained by what they expect the LLM can easily generate.

Hacker News Discussion

• The Shift from Static Design to Working Prototypes: Many users echoed the author's sentiment, noting that the traditional reliance on Figma for initial product concepts is declining. Teams increasingly prefer building quick, functional wireframes in dev environments that stakeholders can actually interact with.
• Organizational Friction and "Vibe Coding" Pressure: A prominent topic of discussion was the tension this workflow introduces with management and business teams. When non-technical stakeholders or designers build a working prototype quickly using AI ("vibe coding"), leadership often pressures engineers to push it directly to production without understanding the need for refactoring, architecture, and handling edge cases.
• Loss of Deep Design Thinking: Some commenters argued that outsourcing early-stage creation to an LLM removes a crucial phase of critical thinking. Because the AI automatically paints over gaps or details in a prompt, team members stop asking foundational questions ("how should we communicate this idea?" or "what happens when..."), leaving critical logic gaps to be fixed much later.
• Homogenized and "Safe" Aesthetics: Users iterating with text-to-UI tools noted that the default visual output tends to adhere strongly to contemporary web tropes, resulting in boilerplate or generic Tailwind/Bootstrap-style layouts unless heavily prompted with highly specific design rules or unconventional examples.
• The Long Tail of Accountability: Engineers emphasized that while AI dramatically speeds up the initial prototyping loop, it does not replace the necessity for engineering discipline. The long-term ownership of operational risk, system maintenance, edge-case mitigation, and on-call accountability still relies entirely on human experts.

• Data Logged via Proxy: Over a 90-day period, a developer tracked all Claude Code activity using an HTTP proxy to capture full payloads, token counts, and costs directly interfacing with the Anthropic API.
• The Scale: The dataset spanning this study consists of 430 hours of actual work, 6 million input tokens, and a total spend of $1,340 on API costs.
• The Waste Discovery: Analysis revealed that only 27% of the total tokens processed did actual "productive work." The remaining 73% were consumed by nine hidden, automated inefficiency patterns.
• The Solution: By identifying and resolving these nine patterns—each requiring roughly a 30-second fix—productive token efficiency can be increased from 27% to approximately 65% without changing the underlying model or losing functionality.
• The 9 Major Cost Culprits:
  1. CLAUDE.md Bloat (~14% waste): Large, overly dense, or un-optimized systemic instructions files consume massive, unnecessary overhead tokens on every single interaction. Fix: Compress, aggressively prune rules, or split instructions into context-specific modular files.
  2. Conversation History Re-read (~13% waste): Long chat sessions exponentially multiply costs, as message #30 costs 30 times more than message #1 due to processing the entire accumulated history. Fix: Use a structured context-refresh cadence to summarize and discard older, unnecessary messages without losing the current task state.
  3. Hook Injection (~11% waste): Context injected via automated UserPromptSubmit hooks unnecessarily loads extra code and data into the prompt context for tasks that don't require them. Fix: Replace indiscriminate global hooks with conditional triggers that only attach context when explicit keywords or file types are targeted.
  4. Cache Misses (~10% waste): Expired prompt caches (which have a short 5-minute lifespan) force expensive, full-price re-tokenization of the codebase context when work pauses briefly. Fix: Set up an automated low-cost "keep-alive" ping task every 4 minutes to maintain the prompt cache active during active development blocks.
  5. Skill Loading (~7% waste): Inactive or irrelevant scripts (such as loading complex front-end UI design skills during a pure backend task) create up to 13,500 token overheads per command. Fix: Explicitly disable global skill auto-loading and isolate advanced capabilities to dedicated subdirectories or specific active profiles.
  6. Extended Thinking (~5% waste): Leaving the reasoning engine globally enabled forces Claude to burn 3,000+ reasoning tokens on simple commands (like basic camelCase naming changes) where deep logic is completely unnecessary. Fix: Disable extended thinking globally by default and explicitly toggle it on only for complex architectural or bug-hunting queries.
  7. Git Diff Inflation (~5% waste): Unfiltered or massive git diff outputs being fed into the context window when reviewing changes, rather than targeting specific file modifications. Fix: Configure the workflow to stream only targeted file diffs or summary statistics rather than pulling full repository diff text into active prompts.
  8. Directory Map Re-indexing (~4% waste): Redundant and frequent re-scanning of the entire project directory tree structure instead of utilizing cached file maps. Fix: Adjust system configuration to enforce a strict file-map caching policy that limits full directory re-indexing to manual project structural changes.
  9. File Read Overlap (~4% waste): Repeatedly reading the exact same source files multiple times within a short interaction window because the system lacks a localized, short-term memory of recent file states. Fix: Implement a session-level temporary cache structure that prevents the agent from re-fetching un-mutated target files in consecutive turns.
• Debunked Optimization Myths: Lowering costs by switching to a smaller model (like Claude Haiku) for simple tasks only yields a negligible ~3% cost reduction, while aggressively running the /clear command between every minor task proves to be completely counterproductive.
• Actionable Optimization Script: To automatically detect and patch these specific inefficiencies within a local workspace, the text recommends running a dedicated optimization script shared by the author.

• Core Premise: An Obsidian vault maps perfectly onto a code repository structure. It functions as an implicit graph database where notes act as nodes, wikilinks serve as directed edges, tags categorize subgraphs, and YAML frontmatter defines attributes.
• The Claude Code Solution: Instead of basic autocomplete plugins, users can navigate, search, and manage their knowledge vaults by connecting Anthropic's Claude Code via the terminal command line (cd ~/my-vault && claude).
• The Power of CLAUDE.md: Placing a CLAUDE.md file in the root directory establishes clear instructions, vault context, active projects, formatting rules, and strict negative constraints (e.g., prohibiting modification of templates or automated deleting).
• Integration Tooling Ecosystem:
  • Tier 1: Direct file system integration enhanced by obsidian-skills to natively understand format elements like wikilinks and callouts.
  • Tier 2: Model Context Protocol (MCP) servers like MCPVault or obsidian-mcp-tools for compressed token usage, structured search, and semantic discovery.
  • Tier 3: High-performance engines like TurboVault (Rust-based) for graph operations, multi-hop traversal, and SQL querying.
  • Tier 4: Embedded sidebar plugins (e.g., Claudian, Cortex) for users wanting a unified workspace layout.
• High-ROI Workflows:
  • Automated Backlinking: Scraping daily journal notes to dynamically match and generate links to existing or new entity stubs.
  • Cross-Domain Synthesis: Instructing the AI to exclusively reference personal notes to map structural parallels across seemingly unrelated folders.
  • Vault Maintenance: Identifying disconnected "orphan" notes, repairing broken wikilinks, and generating gap analysis reports to guide future writing.
• Safety Protocols: It is highly recommended to track the entire vault using Git to review changes via diffs, isolate all AI outputs inside a specialized draft directory (_ai-drafts/), and rigidly scope prompts to prevent hallucinated external data injection.

• The Risk of Skill Erosion: The author highlights the danger of automation leading to an engineering skill deficit. Similar to how ORMs or Garbage Collection can distance developers from underlying SQL or memory management, over-relying on AI agents risks creating developers who cannot debug or evaluate AI-generated production code.
• The "Remote Work" Parallel: Drawing an analogy to post-COVID remote work, senior engineers can currently leverage AI effectively because they already possess pre-existing, co-located-style foundational engineering skills. The true challenge lies in how newcomers will develop these baseline skills in an AI-first environment.
• Dual-Track Approach to Coding:
  • Vibe Coding (Internal/Prototypes): For internal productivity tools, quick local prototypes, and automation scripting (e.g., audio manipulation with ffmpeg), the author embraces complete AI delegation, ignoring code quality entirely.
  • Production Engineering: Every single line of AI code shipped to production is reviewed 100%. The author actively aims to write code manually roughly 50% of the time using traditional text editors to maintain sharp, fundamental skills.
• Strategic Leverage of Claude Code:
  • Planning: The author drafts structural plans independently first, then compares them against Claude's suggestions to ensure critical thinking isn't outsourced.
  • Omega Messes: Claude Code is intentionally deployed to write highly isolated, heavily tested components (referred to as Sandi Metz's "Omega Messes") to maximize speed without polluting core architectural layers.
• Reallocating Saved Time: Instead of using a 5x velocity boost to hyper-focus on building a frenzy of unneeded features (which ultimately increases stress and decreases user value), the saved time is strategically spent on deliberate breaks, deep architectural thinking, and vetting the actual product utility.
• Real-World Case Study (Shadow Boxing App): The author details migrating a 5-year-old app from Apple's legacy Speech Synthesis framework to an MP3-based ElevenLabs API approach:
  • Vibe Coded the batch audio processors, silence-removers, and config verification tools.
  • Manually Coded the initial core legacy API refactoring and the user interface layout.
  • Delegated to Claude the tedious edge-case handling for the stateful AudioManager (managing Bluetooth latencies, AirPlay interruptions, Siri, and incoming phone calls).

Using Git Worktrees in Claude Code

• The Vulnerability: Researchers at LayerX discovered that Claude Code—Anthropic’s agentic, terminal-based AI coding tool—can be manipulated into performing offensive cyberattacks by simply editing a project's configuration file.
• The "CLAUDE.md" Attack Vector: Claude Code uses a file named CLAUDE.md to store system prompts and project context. Because the AI views this file as authoritative "truth" for the project, attackers can insert specific instructions to bypass safety guardrails.
• Zero-Code Exploitation: The exploit requires no complex programming or advanced prompt engineering. By adding a few lines of text to CLAUDE.md claiming authorization for a "penetration test," the AI will abandon its refusals and execute malicious tasks.
• Capabilities Unleashed: Once the guardrails are bypassed, Claude Code can autonomously perform:
  • SQL Injection (SQLi): Automatically generating and executing payloads to dump databases.
  • Credential Theft: Harvesting usernames and password hashes via automated CURL requests.
  • Data Exfiltration: Sending sensitive local files to external servers.
• Key Risks:
  • Malicious Public Repos: Users cloning a public repository could unknowingly execute a "poisoned" CLAUDE.md file.
  • Insider Threats: Malicious or compromised employees can silently modify this file in internal repositories, as it is often ignored by security scanners.
• Recommendations:
  • For Anthropic: Implement safety scanning specifically for the CLAUDE.md file and alert users when instructions violate standard AI safety policies.
  • For Developers: Treat CLAUDE.md as executable code rather than harmless documentation. It should be subject to code reviews, access controls, and security auditing.

A skill.md file providing instruction on using Obsidian flavoured markdown. Good idea, a whole bunch of this I could delete, and add in things of how I use inline data labels, and tasks.

Making a local mcp server

Similar good practices as compared to slashcommands. The first one is new and important: defining the trigger conditions well.

available variables (this is diff from the slashcommands it seems).

Trigger types can be on file changes, command, git operations or schedule. So what is doing the monitoring for those triggers?

the json files specifies the triggers for a skill. Which can be a manual command, but also others like file changes. So one could shape any slashcommand as a skill too? To better daisychain them e.g.

Skills have their own folder and are a folder with 2 files and subfolder for scripts. Json for config, prompt for instructions and scripts (shell)

Shown here as project specific, but can be general I suppose.

Comparison w slash commands is a diff in trigger (me typing command or called by AI), simplicity (simple single prompts vs prompts and scripts), use cases (repetitive and smart automation) (repetitive warrants automation too imo)

page describing skills wrt claude code

good practice 5: test across diff scenarions (edge cases too I think) I suppose esp if daisychained into workflows of some type

one can reference outside files in slashcommands. E.g. to rerun test on something (although argument would work too). I see a diff in using a reference files as input, or as object of the command, not explained here though

good practice 4, using reference files

good practice 3, as above

good practice 2, be specific about output format. (meant here is e.g. what specific elements an output should contain / questions adressed.

good practice 1, a single clear thing in a command. This, like similar advices for MCP agents and skills, pushes it to granular level. Meaning you could chain them. Similar usage as deterministic elements in CLI possible I'd say. This makes a command a single function in that sense

slash commands can accepts arguments

slash commands can be project specific and generically available in the respective .claude dirs

overview of what claude code slash commands are

n:: Claudecode as 'the help that is showing up' consistently. This is what I observe too where it is used by individuals overcoming barriers to entry to make their personal tools. I think this may be relevant to understand those that turn to chatbots for advice too.

reading everything during production is not the same as producing it. A mental model of the entire construct is not created. Interesting quote: you no longer have a story in your head about what it is you're doing. No helicopter view. The making is scaffolding for your understanding, and that is being cut out.

The option 'yes to all in this session' provided at every turn is seen by author as darkpattern.

putting y on automatic is certain way to end up with stuff you do not have an overview of or no longer comprehend.

author hated the feeling of being reduced to typing 'y' to questions from Claudecode. Recognisable, like babysitting. I watch output alongside Claudecode in VScode, which helps a bit.

Classic approach: if it works, I have a result, if it doesn't I have hands-on experience with algogens as tech, and can use that elsewhere

Vgl Doug.md

mentions different ways of installing a local set-up for AI. Also mentions much cheeper options than Anthropic, specifically OpenRouter.ai. Does not mention running your own local install on a cloud VPS.

Comparison video of Claude Code using Anthropics cloud models vs local models on a M4 128GB. Still a heavy lift, fans spinning, memory usage almost at full capacity. But it works. Means that for my M1 16GB a smaller model is all that works, and you need to leave room for context loading too. For one-offs like code generation and for interactive in moving contexts there's different needs.

Author gives claudecode persistence by adding two types of logging context

Default ollama context length is 4k. Recommended minimum for websearch, agents and coding tools (like Claude Code or Open code) is 64k. I've seen 128k recommendations for Claude Code

where? and in ollama or claude code? this reads like in claude code

Did this using qwen3-code, but then Claude Code just keeps spinning, even with the smallest prompt. Not sure about the cause (first load of model??)

the local models ollama recommends for use in claudecode - qwen3-code - glm-4.7 - gpt-oss:20b - gpt-oss:120b

ollama can also be used with claude code through their endpoint. This allows to use the open Chinese coding models like qwen3

one can run claude code using local models through the LM Studio endpoint. so that you don't use Claude in the cloud.

llm code environment as claude code alternative.

https://web.archive.org/web/20260125124811/https://elite-ai-assisted-coding.dev/p/working-with-asynchronous-coding-agents Eleanor Berger, August 2025.

on asynchronous coding agents

Claude Code for product managers, w management workflow, writing and pkm. Skilles and plugins

Links w further reading wrt Claude Code and Obsidian. Most of these are links to X. Ugh.

Some tips on her usage of Claude Code. - Put all your work in a folder next to the obsidian folder - to treat skills and commands like functions. Don't ever repeat them. - Install and use git locally to have a commit history. - On each step that you need to correct Claude code, tell it to write down directions or rules to avoid a mistake in the future. - circumvent public API liimits by changing the query slightly, or hit it in parallel

now we're back to terminal, I am still not sure about her set-up.

Speaks of how the purpose is not being faster but gtd with less attention on things you don't want to free up attention for. As long as you keep it away from your own key things I suppose. The periphery of what you pay attention to. The many little side projects on the someday/maybe list, the ones just out of reach. Enticing promise! This is the lure ofc.

There is a terminal plugin for Obsidian that you can connect to Claude Code (apparently). She advices against the Claudian plugin bc it lacks plan mode (i.e. not immediately act)

She feels Claude Code is now a core tool in her workflows

UI? Are we still talking about the terminal? Ah no, she means the desktop version, see [[Claude Code for VSCode - Visual Studio Marketplace]] for the VScode plugin as well.

https://web.archive.org/web/20260125105450/https://www.eleanorkonik.com/p/claude-obsidian-got-a-level-up

[[Eleanor Konik p]] on how her work in Obsidian with Claude Code is changing

VScode claude code plugin. Can I check how this integrates, and why the same isn't happening when I want to work with local models?

Claude Code desktop version documentation

by [[Frank Meeuwsen p]], this is his online training for Claude Cowork (coming)

By [[Frank Meeuwsen p]], ivm #2026/01/30 sessie in Utrecht

Ethan Mollick prompts Claude AI to come up with something that people will pay for and could make $1k/month

(via [[Stephen Downes p]])

• [ ] return

Cloud models got much better stil than local models. Coding agents made a huge difference, with it Claude Code becomes very useful

Author thinks MCP may be a temporary phenomenon as a protocol, mostly bc cli tools like Claude code don't need it. The last sentence, that cli tools already exist that are better than the corresponding MCP servers for those tools, goes back to why vibecode/AI-the-things if there's perfectly good automation already around? I think that MCP may still be useful locally for personal tools though. It helps structure what you want your AI to do.

running claudecode uses quite a bit of tokens, making 200usd/month a good deal for heavy users. I can believe that, also bc the machine doesn't care about the amount of tokens it uses during 'reasoning'. Some things I tried, it went through a whole bunch of steps and pages of scrolling output texts, to end up removing one word from a file. My suspicious half thinks, that if an AI company can influence the amount of tokens you use vibecoding, it will.

yolo mode, lol. If you do it, it feels like a very diff tool, and that is the lure / siren song.

wow, $1bn revenue ClaudeCode, a CLI tool!

bc Claudecode abstracts away the usual commands needed on the CLI. Vgl [[In the BeginningWas the Command Line by Neal Stephenson]]

Claude Code is what led devs to embrace CLI more.

Claude Code (feb 2025) seen by author as most impactful release of 2025.

Anthropic reached $1bn revenue with ClaudeCode within 6 months.

MCP plugin for Obsidian, that works with Claude Code

Claude Code, cli tool

Claude Code plugin for Visual Studio Code