{"id":21961,"date":"2025-11-02T13:32:19","date_gmt":"2025-11-02T13:32:19","guid":{"rendered":"https:\/\/pokecon.jp\/job\/?p=21961"},"modified":"2025-11-02T13:32:19","modified_gmt":"2025-11-02T13:32:19","slug":"how-i-use-every-claude-code-feature","status":"publish","type":"post","link":"https:\/\/pokecon.jp\/job\/21961\/","title":{"rendered":"How I Use Every Claude Code Feature"},"content":{"rendered":"\n<\/p>\n<div dir=\"auto\">\n<p>I use Claude Code. A lot.<\/p>\n<p><span>As a hobbyist, I run it in a VM several times a week on side projects, often with <\/span><code>--dangerously-skip-permissions<\/code><span> to vibe code whatever idea is on my mind. Professionally, part of my team builds the AI-IDE rules and tooling for our engineering team that consumes <\/span><em>several billion tokens per month<\/em><span> just for codegen.<\/span><\/p>\n<p>The CLI agent space is getting crowded and between Claude Code, Gemini CLI, Cursor, and Codex CLI, it feels like the real race is between Anthropic and OpenAI. But TBH when I talk to other developers, their choice often comes down to what feels like superficials\u2014a \u201clucky\u201d feature implementation or a system prompt \u201cvibe\u201d they just prefer. At this point these tools are all pretty good. I also feel like folks often also over index on the output style or UI. Like to me the \u201cyou\u2019re absolutely right!\u201d sycophancy isn\u2019t a notable bug; it\u2019s a signal that you\u2019re too in-the-loop. Generally my goal is to \u201cshoot and forget\u201d\u2014to delegate, set the context, and let it work. Judging the tool by the final PR and not how it gets there.<\/p>\n<p><span>Having stuck to Claude Code for the last few months, this post is my set of reflections on Claude Code\u2019s entire ecosystem. We\u2019ll cover nearly every feature I use (and, just as importantly, the ones I don\u2019t), from the foundational <\/span><code>CLAUDE.md<\/code><span> file and custom slash commands to the powerful world of Subagents, Hooks, and GitHub Actions. <\/span><strong>This post ended up a bit long and I\u2019d recommend it as more of a reference than something to read in entirety. <\/strong><\/p>\n<p><span>The single most important file in your codebase for using Claude Code effectively is the root <\/span><code>CLAUDE.md<\/code><span>. This file is the agent\u2019s \u201cconstitution,\u201d its primary source of truth for how your specific repository works.<\/span><\/p>\n<p>How you treat this file depends on the context. For my hobby projects, I let Claude dump whatever it wants in there.<\/p>\n<p><span>For my professional work, our monorepo\u2019s <\/span><code>CLAUDE.md<\/code><span> is strictly maintained and currently sits at 13KB (I could easily see it growing to 25KB). <\/span><\/p>\n<ul>\n<li>\n<p>It only documents tools and APIs used by 30% (arbitrary) or more of our engineers (else tools are documented in product or library specific markdown files)<\/p>\n<\/li>\n<li>\n<p><span>We\u2019ve even started allocating effectively a max token count for each internal tool\u2019s documentation, almost like selling \u201cad space\u201d to teams. If you can\u2019t explain your tool concisely, it\u2019s not ready for the <\/span><code>CLAUDE.md<\/code><span>.<\/span><\/p>\n<\/li>\n<\/ul>\n<p><span>Over time, we\u2019ve developed a strong, opinionated philosophy for writing an effective <\/span><code>CLAUDE.md<\/code><span>.<\/span><\/p>\n<ol>\n<li>\n<p><strong>Start with Guardrails, Not a Manual.<\/strong><span> Your <\/span><code>CLAUDE.md<\/code><span> should start small, documenting based on what Claude is getting wrong.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Don\u2019t <\/strong><code>@<\/code><strong>-File Docs.<\/strong><span> If you have extensive documentation elsewhere, it\u2019s tempting to <\/span><code>@<\/code><span>-mention those files in your <\/span><code>CLAUDE.md<\/code><span>. This bloats the context window by embedding the entire file on every run. But if you just <\/span><em>mention<\/em><span> the path, Claude will often ignore it. You have to <\/span><em>pitch<\/em><span> the agent on <\/span><em>why<\/em><span> and <\/span><em>when<\/em><span> to read the file. \u201cFor complex \u2026 usage or if you encounter a <\/span><code>FooBarError<\/code><span>, see <\/span><code>path\/to\/docs.md<\/code><span> for advanced troubleshooting steps.\u201d<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Don\u2019t Just Say \u201cNever.\u201d<\/strong><span> Avoid negative-only constraints like \u201cNever use the <\/span><code>--foo-bar<\/code><span> flag.\u201d The agent will get stuck when it thinks it <\/span><em>must<\/em><span> use that flag. Always provide an alternative.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Use <\/strong><code>CLAUDE.md<\/code><strong> as a Forcing Function.<\/strong><span> If your CLI commands are complex and verbose, don\u2019t write paragraphs of documentation to explain them. That\u2019s patching a human problem. Instead, write a simple bash wrapper with a clear, intuitive API and document <\/span><em>that<\/em><span>. Keeping your <\/span><code>CLAUDE.md<\/code><span> as short as possible is a fantastic forcing function for simplifying your codebase and internal tooling.<\/span><\/p>\n<\/li>\n<\/ol>\n<p>Here\u2019s a simplified snapshot:<\/p>\n<pre><code><code># Monorepo\n\n## Python\n- Always ...\n- Test with <command>\n... 10 more ...\n\n## <internal cli=\"\" tool=\"\">\n... 10 bullets, focused on the 80% of use cases ...\n- <usage example=\"\">\n- Always ...\n- Never <x>, prefer <y>\n\nFor <complex usage=\"\"> or <error> see path\/to\/<tool>_docs.md\n\n...<\/tool><\/error><\/complex><\/y><\/x><\/usage><\/internal><\/command><\/code><\/code><\/pre>\n<p><span>Finally, we keep this file synced with an <\/span><code>AGENTS.md<\/code><span> file to maintain compatibility with other AI IDEs that our engineers might be using.<\/span><\/p>\n<p><em><span>If you are looking for more tips for writing markdown for coding agents see <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/ai-cant-read-your-docs\" rel=\"\">\u201cAI Can\u2019t Read Your Docs\u201d,<\/a><span> <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/ai-powered-software-engineering\" rel=\"\">\u201cAI-powered Software Engineering\u201d,<\/a><span> and <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/how-cursor-ai-ide-works\" rel=\"\">\u201cHow Cursor (AI IDE) Works\u201d.<\/a><\/em><\/p>\n<p><strong>The Takeaway:<\/strong><span> Treat your <\/span><code>CLAUDE.md<\/code><span> as a high-level, curated set of guardrails and pointers. Use it to guide where you need to invest in more AI (and human) friendly tools, rather than trying to make it a comprehensive manual.<\/span><\/p>\n<p><span>I recommend running <\/span><code>\/context<\/code><span> mid coding session at least once to understand how you are using your 200k token context window (even with Sonnet-1M, I don\u2019t trust that the full context window is actually used effectively). For us a fresh session in our monorepo costs a baseline ~20k tokens (10%) with the remaining 180k for making your change \u2014 which can fill up quite fast.<\/span><\/p>\n<div class=\"captioned-image-container\">\n<figure><a target=\"_blank\" target=\"_blank\" href=\"https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png\" data-component-name=\"Image2ToDOM\" rel=\"\" class=\"image-link image2 is-viewable-img\"><\/p>\n<div class=\"image2-inset\"><picture><source type=\"image\/webp\" srcset=\"https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_424,c_limit,f_webp,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 424w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_848,c_limit,f_webp,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 848w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_1272,c_limit,f_webp,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 1272w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_1456,c_limit,f_webp,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 1456w\" sizes=\"100vw\"\/><img decoding=\"async\" src=\"https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png\" width=\"638\" height=\"396.6839378238342\" data-attrs=\"{&quot;src&quot;:&quot;https:\/\/substack-post-media.s3.amazonaws.com\/public\/images\/7ee93292-646a-407a-95da-d469be81002e_1158x720.png&quot;,&quot;srcNoWatermark&quot;:null,&quot;fullscreen&quot;:null,&quot;imageSize&quot;:null,&quot;height&quot;:720,&quot;width&quot;:1158,&quot;resizeWidth&quot;:638,&quot;bytes&quot;:120380,&quot;alt&quot;:null,&quot;title&quot;:null,&quot;type&quot;:&quot;image\/png&quot;,&quot;href&quot;:null,&quot;belowTheFold&quot;:true,&quot;topImage&quot;:false,&quot;internalRedirect&quot;:&quot;https:\/\/blog.sshh.io\/i\/177742847?img=https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png&quot;,&quot;isProcessing&quot;:false,&quot;align&quot;:null,&quot;offset&quot;:false}\" alt=\"\" srcset=\"https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_424,c_limit,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 424w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_848,c_limit,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 848w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_1272,c_limit,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 1272w, https:\/\/substackcdn.com\/image\/fetch\/$s_!o_oM!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep\/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7ee93292-646a-407a-95da-d469be81002e_1158x720.png 1456w\" sizes=\"auto, 100vw\" loading=\"lazy\" class=\"sizing-normal\"\/><\/picture><\/div>\n<p><\/a><figcaption class=\"image-caption\"><span>A screenshot of <\/span><strong>\/context<\/strong><span> in one of my recent side projects. You can almost think of this like disk space that fills up as you work on a feature. After a few minutes or hours you\u2019ll need to clear the messages (purple) to make space to continue.<\/span><\/figcaption><\/figure>\n<\/div>\n<p>I have three main workflows:<\/p>\n<ul>\n<li>\n<p><code>\/compact<\/code><strong> (Avoid):<\/strong><span> I avoid this as much as possible. The automatic compaction is opaque, error-prone, and not well-optimized.<\/span><\/p>\n<\/li>\n<li>\n<p><code>\/clear<\/code><strong> + <\/strong><code>\/catchup<\/code><strong> (Simple Restart):<\/strong><span> My default reboot. I <\/span><code>\/clear<\/code><span> the state, then run a custom <\/span><code>\/catchup<\/code><span> command to make Claude read all changed files in my git branch.<\/span><\/p>\n<\/li>\n<li>\n<p><span>\u201cDocument &amp; Clear\u201d<\/span><strong> (Complex Restart):<\/strong><span> For large tasks. I have Claude dump its plan and progress into a <\/span><code>.md<\/code><span>, <\/span><code>\/clear<\/code><span> the state, then start a new session by telling it to read the <\/span><code>.md<\/code><span> and continue.<\/span><\/p>\n<\/li>\n<\/ul>\n<p><strong>The Takeaway:<\/strong><span> Don\u2019t trust auto-compaction. Use <\/span><code>\/clear<\/code><span> for simple reboots and the \u201cDocument &amp; Clear\u201d method to create durable, external \u201cmemory\u201d for complex tasks.<\/span><\/p>\n<p>I think of slash commands as simple shortcuts for frequently used prompts, nothing more. My setup is minimal:<\/p>\n<ul>\n<li>\n<p><code>\/catchup<\/code><span>: The command I mentioned earlier. It just prompts Claude to read all changed files in my current git branch.<\/span><\/p>\n<\/li>\n<li>\n<p><code>\/pr<\/code><span>: A simple helper to clean up my code, stage it, and prepare a pull request.<\/span><\/p>\n<\/li>\n<\/ul>\n<p><span>IMHO if you have a long list of complex, custom slash commands, you\u2019ve created an anti-pattern. To me the entire point of an agent like Claude is that you can type <\/span><em>almost<\/em><span> whatever you want and get a useful, mergable result. The moment you force an engineer (or non-engineer) to learn a new, documented-somewhere list of essential magic commands just to get work done, you\u2019ve failed.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Use slash commands as simple, personal shortcuts, not as a replacement for building a more intuitive <\/span><code>CLAUDE.md<\/code><span> and better-tooled agent.<\/span><\/p>\n<p><span>On paper, custom subagents are Claude Code\u2019s most powerful feature for context management. The pitch is simple: a complex task requires <\/span><code>X<\/code><span> tokens of input context (e.g., how to run tests), accumulates <\/span><code>Y<\/code><span> tokens of working context, and produces a <\/span><code>Z<\/code><span> token answer. Running <\/span><code>N<\/code><span> tasks means <\/span><code>(X + Y + Z) * N<\/code><span> tokens in your main window.<\/span><\/p>\n<p><span>The subagent solution is to farm out the <\/span><code>(X + Y) * N<\/code><span> work to specialized agents, which only return the final <\/span><code>Z<\/code><span> token answers, keeping your main context clean.<\/span><\/p>\n<p><span>I find they are a powerful idea that, in practice, <\/span><em>custom<\/em><span> subagents create two new problems:<\/span><\/p>\n<ol>\n<li>\n<p><strong>They Gatekeep Context:<\/strong><span> If I make a <\/span><code>PythonTests<\/code><span> subagent, I\u2019ve now hidden all testing context from my <\/span><em>main<\/em><span> agent. It can no longer reason holistically about a change. It\u2019s now forced to invoke the subagent just to know how to validate its own code.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>They Force Human Workflows:<\/strong><span> Worse, they force Claude into a rigid, human-defined workflow. I\u2019m now dictating <\/span><em>how<\/em><span> it must delegate, which is the very problem I\u2019m trying to get the agent to solve for me.<\/span><\/p>\n<\/li>\n<\/ol>\n<p><span>My preferred alternative is to use Claude\u2019s built-in <\/span><code>Task(...)<\/code><span> feature to spawn clones of the <\/span><em>general<\/em><span> agent.<\/span><\/p>\n<p><span>I put all my key context in the <\/span><code>CLAUDE.md<\/code><span>. Then, I let the <\/span><em>main agent<\/em><span> decide when and how to delegate work to copies of itself. This gives me all the context-saving benefits of subagents without the drawbacks. The agent manages its own orchestration dynamically.<\/span><\/p>\n<p><span>In my <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/building-multi-agent-systems-part\" rel=\"\">\u201cBuilding Multi-Agent Systems (Part 2)\u201d<\/a><span> post, I called this the \u201cMaster-Clone\u201d architecture, and I strongly prefer it over the \u201cLead-Specialist\u201d model that custom subagents encourage.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Custom subagents are a brittle solution. Give your main agent the context (in <\/span><code>CLAUDE.md<\/code><span>) and let it use its own <\/span><code>Task\/Explore(...)<\/code><span> feature to manage delegation.<\/span><\/p>\n<p><span>On a simple level, I use <\/span><code>claude --resume<\/code><span> and <\/span><code>claude --continue<\/code><span> frequently. They\u2019re great for restarting a bugged terminal or quickly rebooting an older session. I\u2019ll often <\/span><code>claude --resume<\/code><span> a session from days ago just to ask the agent to summarize how it overcame a specific error, which I then use to improve our <\/span><code>CLAUDE.md<\/code><span> and internal tooling.<\/span><\/p>\n<p><span>More in the weeds, Claude Code stores all session history in <\/span><code>~\/.claude\/projects\/<\/code><span> to tap into the raw historical session data. I have scripts that run meta-analysis on these logs, looking for common exceptions, permission requests, and error patterns to help improve agent-facing context.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Use <\/span><code>claude --resume<\/code><span> and <\/span><code>claude --continue <\/code><span>to restart sessions and uncover buried historical context.<\/span><\/p>\n<p><span>Hooks are huge. I don\u2019t use them for hobby projects, but they are critical for steering Claude in a complex enterprise repo. They are the deterministic \u201cmust-do\u201d rules that complement the \u201cshould-do\u201d suggestions in <\/span><code>CLAUDE.md<\/code><span>.<\/span><\/p>\n<p>We use two types:<\/p>\n<ol>\n<li>\n<p><strong>Block-at-Submit Hooks:<\/strong><span> This is our primary strategy. We have a <\/span><code>PreToolUse<\/code><span> hook that wraps any <\/span><code>Bash(git commit)<\/code><span> command. It checks for a <\/span><code>\/tmp\/agent-pre-commit-pass<\/code><span> file, which our test script <\/span><em>only<\/em><span> creates if all tests pass. If the file is missing, the hook blocks the commit, forcing Claude into a \u201ctest-and-fix\u201d loop until the build is green.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Hint Hooks:<\/strong><span> These are simple, non-blocking hooks that provide \u201cfire-and-forget\u201d feedback if the agent is doing something suboptimal.<\/span><\/p>\n<\/li>\n<\/ol>\n<p><span>We intentionally do not use \u201cblock-at-write\u201d hooks (e.g., on <\/span><code>Edit<\/code><span> or <\/span><code>Write<\/code><span>). Blocking an agent mid-plan confuses or even \u201cfrustrates\u201d it. It\u2019s far more effective to let it finish its work and then check the final, completed result at the commit stage.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Use hooks to enforce state validation at commit time (<\/span><code>block-at-submit<\/code><span>). Avoid blocking at write time\u2014let the agent finish its plan, then check the final result.<\/span><\/p>\n<p>Planning is essential for any \u201clarge\u201d feature change with an AI IDE.<\/p>\n<p><span>For my hobby projects, I exclusively use the built-in planning mode. It\u2019s a way to align with Claude before it starts, defining both <\/span><em>how<\/em><span> to build something and the \u201cinspection checkpoints\u201d where it needs to stop and show me its work. Using this regularly builds a strong intuition for what minimal context is needed to get a good plan without Claude botching the implementation.<\/span><\/p>\n<p>In our work monorepo, we\u2019ve started rolling out a custom planning tool built on the Claude Code SDK. Its similar to native plan mode but heavily prompted to align its outputs with our existing technical design format. It also enforces our internal best practices\u2014from code structure to data privacy and security\u2014out of the box. This lets our engineers \u201cvibe plan\u201d a new feature as if they were a senior architect (or at least that\u2019s the pitch).<\/p>\n<p><strong>The Takeaway:<\/strong><span> Always use the built-in planning mode for complex changes to align on a plan before the agent starts working.<\/span><\/p>\n<p><span>I agree with <\/span><a target=\"_blank\" href=\"https:\/\/simonwillison.net\/2025\/Oct\/16\/claude-skills\/\" rel=\"\">Simon Willison\u2019s<\/a><span>: <\/span><strong>Skills are (maybe) a bigger deal than MCP.<\/strong><\/p>\n<p><span>If you\u2019ve been following my posts, you\u2019ll know I\u2019ve drifted away from MCP for most dev workflows, preferring to build simple CLIs instead (as I argued in <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/ai-cant-read-your-docs\" rel=\"\">\u201cAI Can\u2019t Read Your Docs\u201d<\/a><span>). My mental model for agent autonomy has evolved into three stages:<\/span><\/p>\n<ol>\n<li>\n<p><strong>Single Prompt:<\/strong><span> Giving the agent all context in one massive prompt. (Brittle, doesn\u2019t scale).<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Tool Calling:<\/strong><span> The \u201cclassic\u201d agent model. We hand-craft tools and abstract away reality for the agent. (Better, but creates new abstractions and context bottlenecks).<\/span><\/p>\n<\/li>\n<li>\n<p><strong><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/i\/167598476\/scripting-agents\" rel=\"\">Scripting<\/a><span>:<\/span><\/strong><span> We give the agent access to the raw environment\u2014binaries, scripts, and docs\u2014and it writes code <\/span><em>on the fly<\/em><span> to interact with them.<\/span><\/p>\n<\/li>\n<\/ol>\n<p><span>With this model in mind, <\/span><strong>Agent Skills<\/strong><span> are the obvious next feature. They are the formal productization of the \u201cScripting\u201d layer.<\/span><\/p>\n<p><span>If, like me, you\u2019ve already been <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/i\/171208815\/pattern-choose-the-right-interface-cli-vs-mcp\" rel=\"\">favoring CLIs over MCP,<\/a><span> you\u2019ve been implicitly getting the benefit of Skills all along. The <\/span><code>SKILL.md<\/code><span> file is just a more organized, shareable, and discoverable way to document these CLIs and scripts and expose them to the agent.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Skills are the right abstraction. They formalize the \u201cscripting\u201d-based agent model, which is more robust and flexible than the rigid, API-like model that MCP represents.<\/span><\/p>\n<p><span>Skills don\u2019t mean MCP is dead (see also <\/span><a target=\"_blank\" href=\"https:\/\/blog.sshh.io\/p\/everything-wrong-with-mcp\" rel=\"\">\u201cEverything Wrong with MCP\u201d<\/a><span>). Previously, many built awful, context-heavy MCPs with dozens of tools that just mirrored a REST API (<\/span><code>read_thing_a()<\/code><span>, <\/span><code>read_thing_b()<\/code><span>, <\/span><code>update_thing_c()<\/code><span>). <\/span><\/p>\n<p>The \u201cScripting\u201d model (now formalized by Skills) is better, but it needs a secure way to access the environment. This to me is the new, more focused role for MCP.<\/p>\n<p>Instead of a bloated API, an MCP should be a simple, secure gateway that provides a few powerful, high-level tools:<\/p>\n<ul>\n<li>\n<p><code>download_raw_data(filters\u2026)<\/code><\/p>\n<\/li>\n<li>\n<p><code>take_sensitive_gated_action(args\u2026)<\/code><\/p>\n<\/li>\n<li>\n<p><code>execute_code_in_environment_with_state(code\u2026)<\/code><\/p>\n<\/li>\n<\/ul>\n<p><span>In this model, MCP\u2019s job isn\u2019t to abstract reality for the agent; its job is to manage the auth, networking, and security boundaries and then get out of the way. It provides the <\/span><em>entry point<\/em><span> for the agent, which then uses its scripting and <\/span><code>markdown<\/code><span> context to do the actual work.<\/span><\/p>\n<p><span>The only MCP I still use is for <\/span><a target=\"_blank\" href=\"https:\/\/github.com\/microsoft\/playwright-mcp\" rel=\"\">Playwright<\/a><span>, which makes sense\u2014it\u2019s a complex, stateful environment. All my stateless tools (like Jira, AWS, GitHub) have been migrated to simple CLIs.<\/span><\/p>\n<p><strong>The Takeaway:<\/strong><span> Use MCPs that act as data gateways. Give the agent one or two high-level tools (like a raw data dump API) that it can then script against.<\/span><\/p>\n<p>Claude Code isn\u2019t just an interactive CLI; it\u2019s also a powerful SDK for building entirely new agents\u2014for both coding and non-coding tasks. I\u2019ve started using it as my default agent framework over tools like LangChain\/CrewAI for most new hobby projects.<\/p>\n<p>I use it in three main ways:<\/p>\n<ol>\n<li>\n<p><strong>Massive Parallel Scripting:<\/strong><span> For large-scale refactors, bug fixes, or migrations, I don\u2019t use the interactive chat. I write simple bash scripts that call <\/span><code>claude -p \u201cin \/pathA change all refs from foo to bar\u201d<\/code><span> in parallel. This is far more scalable and controllable than trying to get the main agent to manage dozens of subagent tasks.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Building Internal Chat Tools:<\/strong><span> The SDK is perfect for wrapping complex processes in a simple chat interface for non-technical users. Like an installer that, on error, falls back to the Claude Code SDK to just <\/span><em>fix<\/em><span> the problem for the user. Or an in-house \u201c<\/span><a target=\"_blank\" href=\"http:\/\/v0.dev\/\" rel=\"\">v0-at-home<\/a><span>\u201d tool that lets our design team vibe-code mock frontends in our in-house UI framework, ensuring their ideas are high-fidelity and the code is more directly usable in frontend production code.<\/span><\/p>\n<\/li>\n<li>\n<p><strong>Rapid Agent Prototyping:<\/strong><span> This is my most common use. It\u2019s not just for coding. If I have an idea for any agentic task (e.g., a \u201cthreat investigation agent\u201d that uses custom CLIs or MCPs), I use the Claude Code SDK to quickly build and test the prototype before committing to a full, deployed scaffolding.<\/span><\/p>\n<\/li>\n<\/ol>\n<p><strong>The Takeaway:<\/strong><span> The Claude Code SDK is a powerful, general-purpose agent framework. Use it for batch-processing code, building internal tools, and rapidly prototyping new agents <\/span><em>before<\/em><span> you reach for more complex frameworks.<\/span><\/p>\n<p>The Claude Code GitHub Action (GHA) is probably one of my favorite and most slept on features. It\u2019s a simple concept: just run Claude Code in a GHA. But this simplicity is what makes it so powerful.<\/p>\n<p><span>It\u2019s similar to <\/span><a target=\"_blank\" href=\"https:\/\/cursor.com\/docs\/cloud-agent\" rel=\"\">Cursor\u2019s background agents<\/a><span> or the Codex managed web UI but is far more customizable. You control the entire container and environment, giving you more access to data and, crucially, much stronger sandboxing and audit controls than any other product provides. Plus, it supports all the advanced features like Hooks and MCP.<\/span><\/p>\n<p><span>We\u2019ve used it to build custom \u201cPR-from-anywhere\u201d tooling. Users can trigger a PR from Slack, Jira, or even a CloudWatch alert, and the GHA will fix the bug or add the feature and return a fully tested PR<\/span><span>.<\/span><\/p>\n<p>Since the GHA logs are the full agent logs, we have an ops process to regularly review these logs at a company level for common mistakes, bash errors, or unaligned engineering practices. This creates a data-driven flywheel: Bugs -&gt; Improved CLAUDE.md \/ CLIs -&gt; Better Agent.<\/p>\n<pre><code>$ query-claude-gha-logs --since 5d | claude -p \u201csee what the other claudes were getting stuck on and fix it, then put up a PR\u201c<\/code><\/pre>\n<p><strong>The Takeaway:<\/strong><span> The GHA is the ultimate way to operationalize Claude Code. It turns it from a personal tool into a core, auditable, and self-improving part of your engineering system.<\/span><\/p>\n<p><span>Finally, I have a few specific <\/span><code>settings.json<\/code><span> configurations that I\u2019ve found essential for both hobby and professional work.<\/span><\/p>\n<ul>\n<li>\n<p><code>HTTPS_PROXY<\/code><span>\/<\/span><code>HTTP_PROXY<\/code><span>: This is great for debugging. I\u2019ll use it to inspect the raw traffic to see exactly what prompts Claude is sending. For background agents, it\u2019s also a powerful tool for fine-grained network sandboxing.<\/span><\/p>\n<\/li>\n<li>\n<p><code>MCP_TOOL_TIMEOUT<\/code><span>\/<\/span><code>BASH_MAX_TIMEOUT_MS<\/code><span>: I bump these. I like running long, complex commands, and the default timeouts are often too conservative. I\u2019m honestly not sure if this is still needed now that bash background tasks are a thing, but I keep it just in case.<\/span><\/p>\n<\/li>\n<li>\n<p><code>ANTHROPIC_API_KEY<\/code><span>: At work, we use our enterprise API keys (<\/span><a target=\"_blank\" href=\"https:\/\/www.reddit.com\/r\/ClaudeAI\/comments\/1jwvssa\/comment\/mtt0urz\/?utm_source=share&amp;utm_medium=web3x&amp;utm_name=web3xcss&amp;utm_term=1&amp;utm_content=share_button\" rel=\"\">via apiKeyHelper<\/a><span>). It shifts us from a \u201cper-seat\u201d license to \u201cusage-based\u201d pricing, which is a much better model for how we work.<\/span><\/p>\n<ul>\n<li>\n<p><span>It accounts for the <\/span><em>massive<\/em><span> variance in developer usage (We\u2019ve seen 1:100x differences between engineers).<\/span><\/p>\n<\/li>\n<li>\n<p>It lets engineers to tinker with non-Claude-Code LLM scripts, all under our single enterprise account.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><code>\u201cpermissions\u201d<\/code><span>: I\u2019ll occasionally self-audit the list of commands I\u2019ve allowed Claude to auto-run.<\/span><\/p>\n<\/li>\n<\/ul>\n<p><strong>The Takeaway:<\/strong><span> Your <\/span><code>settings.json<\/code><span> is a powerful place for advanced customization.<\/span><\/p>\n<p>That was a lot, but hopefully, you find it useful. If you\u2019re not already using a CLI-based agent like Claude Code or Codex CLI, you probably should be. There are rarely good guides for these advanced features, so the only way to learn is to dive in.<\/p>\n<\/div>\n\n<br \/><a href=\"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature\">\u5143\u306e\u8a18\u4e8b\u3092\u78ba\u8a8d\u3059\u308b <\/a><\/p>\n","protected":false},"excerpt":{"rendered":"I use Claude Code. A lot. As a hobbyist, I run it in a VM several times a week on side projects, often with -- [&hellip;]","protected":false},"author":1,"featured_media":21962,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-21961","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-hatena-blog"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.6 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature\" \/>\n<meta property=\"og:locale\" content=\"ja_JP\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3\" \/>\n<meta property=\"og:description\" content=\"I use Claude Code. A lot. As a hobbyist, I run it in a VM several times a week on side projects, often with -- [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature\" \/>\n<meta property=\"og:site_name\" content=\"\u30dd\u30b1\u30b3\u30f3\" \/>\n<meta property=\"article:published_time\" content=\"2025-11-02T13:32:19+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg\" \/>\n\t<meta property=\"og:image:width\" content=\"1158\" \/>\n\t<meta property=\"og:image:height\" content=\"600\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"info@pokecon.jp\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u57f7\u7b46\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"info@pokecon.jp\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u63a8\u5b9a\u8aad\u307f\u53d6\u308a\u6642\u9593\" \/>\n\t<meta name=\"twitter:data2\" content=\"16\u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/21961\\\/\"},\"author\":{\"name\":\"info@pokecon.jp\",\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/#\\\/schema\\\/person\\\/16c9f07b1ba984d165d9aee259bda997\"},\"headline\":\"How I Use Every Claude Code Feature\",\"datePublished\":\"2025-11-02T13:32:19+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/21961\\\/\"},\"wordCount\":2924,\"image\":{\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/wp-content\\\/uploads\\\/2025\\\/11\\\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg\",\"articleSection\":[\"\u306f\u3066\u306a\u30d6\u30ed\u30b0\"],\"inLanguage\":\"ja\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/21961\\\/\",\"url\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature\",\"name\":\"How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/wp-content\\\/uploads\\\/2025\\\/11\\\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg\",\"datePublished\":\"2025-11-02T13:32:19+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/#\\\/schema\\\/person\\\/16c9f07b1ba984d165d9aee259bda997\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#breadcrumb\"},\"inLanguage\":\"ja\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"ja\",\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#primaryimage\",\"url\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/wp-content\\\/uploads\\\/2025\\\/11\\\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg\",\"contentUrl\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/wp-content\\\/uploads\\\/2025\\\/11\\\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg\",\"width\":1158,\"height\":600},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/blog.sshh.io\\\/p\\\/how-i-use-every-claude-code-feature#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u30db\u30fc\u30e0\",\"item\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How I Use Every Claude Code Feature\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/#website\",\"url\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/\",\"name\":\"\u30dd\u30b1\u30b3\u30f3\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"ja\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/#\\\/schema\\\/person\\\/16c9f07b1ba984d165d9aee259bda997\",\"name\":\"info@pokecon.jp\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"ja\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g\",\"caption\":\"info@pokecon.jp\"},\"url\":\"https:\\\/\\\/pokecon.jp\\\/job\\\/author\\\/infopokecon-jp\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature","og_locale":"ja_JP","og_type":"article","og_title":"How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3","og_description":"I use Claude Code. A lot. As a hobbyist, I run it in a VM several times a week on side projects, often with -- [&hellip;]","og_url":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature","og_site_name":"\u30dd\u30b1\u30b3\u30f3","article_published_time":"2025-11-02T13:32:19+00:00","og_image":[{"width":1158,"height":600,"url":"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg","type":"image\/jpeg"}],"author":"info@pokecon.jp","twitter_card":"summary_large_image","twitter_misc":{"\u57f7\u7b46\u8005":"info@pokecon.jp","\u63a8\u5b9a\u8aad\u307f\u53d6\u308a\u6642\u9593":"16\u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#article","isPartOf":{"@id":"https:\/\/pokecon.jp\/job\/21961\/"},"author":{"name":"info@pokecon.jp","@id":"https:\/\/pokecon.jp\/job\/#\/schema\/person\/16c9f07b1ba984d165d9aee259bda997"},"headline":"How I Use Every Claude Code Feature","datePublished":"2025-11-02T13:32:19+00:00","mainEntityOfPage":{"@id":"https:\/\/pokecon.jp\/job\/21961\/"},"wordCount":2924,"image":{"@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#primaryimage"},"thumbnailUrl":"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg","articleSection":["\u306f\u3066\u306a\u30d6\u30ed\u30b0"],"inLanguage":"ja"},{"@type":"WebPage","@id":"https:\/\/pokecon.jp\/job\/21961\/","url":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature","name":"How I Use Every Claude Code Feature - \u30dd\u30b1\u30b3\u30f3","isPartOf":{"@id":"https:\/\/pokecon.jp\/job\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#primaryimage"},"image":{"@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#primaryimage"},"thumbnailUrl":"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg","datePublished":"2025-11-02T13:32:19+00:00","author":{"@id":"https:\/\/pokecon.jp\/job\/#\/schema\/person\/16c9f07b1ba984d165d9aee259bda997"},"breadcrumb":{"@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#breadcrumb"},"inLanguage":"ja","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature"]}]},{"@type":"ImageObject","inLanguage":"ja","@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#primaryimage","url":"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg","contentUrl":"https:\/\/pokecon.jp\/job\/wp-content\/uploads\/2025\/11\/https3A2F2Fsubstack-post-media.s3.amazonaws.com2Fpublic2Fimages2F7ee93292-646a-407a-95da-d469b.jpeg","width":1158,"height":600},{"@type":"BreadcrumbList","@id":"https:\/\/blog.sshh.io\/p\/how-i-use-every-claude-code-feature#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u30db\u30fc\u30e0","item":"https:\/\/pokecon.jp\/job\/"},{"@type":"ListItem","position":2,"name":"How I Use Every Claude Code Feature"}]},{"@type":"WebSite","@id":"https:\/\/pokecon.jp\/job\/#website","url":"https:\/\/pokecon.jp\/job\/","name":"\u30dd\u30b1\u30b3\u30f3","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/pokecon.jp\/job\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"ja"},{"@type":"Person","@id":"https:\/\/pokecon.jp\/job\/#\/schema\/person\/16c9f07b1ba984d165d9aee259bda997","name":"info@pokecon.jp","image":{"@type":"ImageObject","inLanguage":"ja","@id":"https:\/\/secure.gravatar.com\/avatar\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2b0549cd9f7907c092ca5fbb283baf72337f235726e4b46fa39ec0b701ac2fe2?s=96&d=wavatar&r=g","caption":"info@pokecon.jp"},"url":"https:\/\/pokecon.jp\/job\/author\/infopokecon-jp\/"}]}},"_links":{"self":[{"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/posts\/21961","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/comments?post=21961"}],"version-history":[{"count":1,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/posts\/21961\/revisions"}],"predecessor-version":[{"id":21963,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/posts\/21961\/revisions\/21963"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/media\/21962"}],"wp:attachment":[{"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/media?parent=21961"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/categories?post=21961"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/pokecon.jp\/job\/wp-json\/wp\/v2\/tags?post=21961"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}