DEV Community: naoki_JPN

I Built a Claude Code Plugin That Simultaneously Posts to Zenn and dev.to With Just "Publish the article"

naoki_JPN — Fri, 17 Apr 2026 04:31:47 +0000

I built a plugin for Claude Code that simultaneously posts to Zenn (in Japanese) and dev.to (in English translation) just by saying "publish the article."

What I Built

zenn-post — Claude Code Plugin / Skill

https://github.com/bokuno-studio/zenn-post-cc-plugin

This plugin handles the entire article publishing workflow — creating drafts, formatting Markdown, running git push, and calling the dev.to API — all delegated to Claude Code.

What It Can Do

"Publish the article" → simultaneously posts to Zenn (Japanese) and dev.to (English translation)
Pass a Notion page URL → reads the content, converts it to an article, and posts it
Just describe a topic verbally → fully automated from writing to git push
Automatically converts Mermaid diagrams to PNG locally (no external services)
Preview before publishing → runs git push after your OK

"Upload this Notion page to Zenn"
"Publish the article"          ← Posts to both Zenn + dev.to
"Post to Zenn only"            ← Zenn only

Why I Built It

The Zenn posting workflow was quietly tedious:

Create a Markdown file
Write the frontmatter
Write the content
Change published: true
git commit & push
(If also posting to dev.to) Translate to English and call the API

Doing this every time felt like a chore, so I thought "let Claude Code handle all of it."

Technical Highlights

Implemented as a Claude Code Skill (SKILL.md)

Claude Code has a plugin/skill feature where you can register a skill just by writing a prompt in SKILL.md. No code needed at all — you just define "how it should behave" in natural language.

skills/zenn-post/SKILL.md  ← that's it

Direct POST to dev.to via curl

The dev.to API is simple — a single curl request does the job. Claude Code reads the API key from .env and assembles the request.

curl -X POST https://dev.to/api/articles \
  -H "api-key: $DEVTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "article": { "title": "...", "published": true, "body_markdown": "..." } }'

Mermaid Diagrams Converted to PNG Locally

Since dev.to doesn't render Mermaid, this plugin uses mermaid-cli for local conversion into images. The converted PNG is stored in the images/ directory of the zenn-content repository and served via raw.githubusercontent.com — no external services involved.

npx @mermaid-js/mermaid-cli -i diagram.mmd -o diagram.png -t default -b white

Installation

Prerequisites:

Claude Code installed
A Zenn account and zenn-content repository (public) on GitHub
A dev.to account and API key

Steps:

git clone https://github.com/bokuno-studio/zenn-post-cc-plugin ~/.claude/plugins/zenn-post

Edit the environment info section in skills/zenn-post/SKILL.md with your own paths, then register it with Claude Code.

claude plugin marketplace add ~/.claude/plugins/zenn-post
claude plugin install zenn-post

Changelog

Version	Date	Changes
v0.1.0	2026-04-16	Initial release (Zenn posting only)
v0.2.0	2026-04-17	Added dev.to simultaneous posting and Mermaid CLI support

Wrapping Up

Using Claude Code's Skill feature, you can take a new approach to automation: "define Claude's behavior without writing code." Extracting routine tasks like article publishing into a skill makes it satisfying to complete everything with just a verbal instruction.

Feel free to give it a try — feedback welcome!

I Built a Sales Prep AI and It Went Deeper Than Expected

naoki_JPN — Fri, 17 Apr 2026 01:55:37 +0000

Introduction

"Before a first sales meeting, you always research the other company. That part is kind of a pain, right?"

That thought is where this started. I wanted something that would take a company name and automatically research it, then return a report.

I figured I could get something working in 2–3 days. But getting it to a genuinely usable level turned out to be much deeper than expected. This is the story of that process.

What I built: Sales Prep AI (LINE bot)

https://pre-talk.vercel.app

Tech Stack

How It Came Together

Phase 1: Just Get It Working

I started with a simple web form. Enter company name, department, and contact name → it searches the web → GPT-4o-mini analyzes the results → returns a report.

As I worked on improving reasoning quality, I switched from GPT-4o-mini to Claude Sonnet for the analysis layer. Light input-interpretation tasks go to Claude Haiku; heavy analysis and OCR go to Claude Sonnet. That division of labor stuck.

For search, I started with DuckDuckGo, but the quality wasn't great, so I switched to Tavily. That one change made a noticeable difference in search quality.

Phase 2: Fighting Vercel Hobby's 10-Second Timeout

Research involves multiple steps — search, then AI analysis — and it realistically takes 1–2 minutes. Vercel's Hobby plan times out at 10 seconds.

The solution: streaming responses. By returning a response while continuing to process, you keep the function alive.

const stream = new ReadableStream({
  async start(controller) {
    const heartbeat = setInterval(() => {
      controller.enqueue(new TextEncoder().encode(" "));
    }, 5000);

    try {
      // Heavy processing happens here
      await runResearch(input);
    } finally {
      clearInterval(heartbeat);
      controller.close();
    }
  },
});

return new Response(stream, { status: 200 });

Sending a blank space every 5 seconds keeps the connection alive. Brute-force, but it works.

Phase 3: Slack Bot → LINE Bot

A web form creates friction — you have to actively open it when you need it. It's better to use it from a tool you already have open.

I built a Slack bot first. But when I ended up canceling the paid Slack plan I was using, I migrated to LINE.

Phase 4: Fighting Hallucinations

This was the hardest part.

The AI was confidently returning information that sounded plausible but wasn't true. Specifically:

Asserting fabricated problems as "challenges faced by [department]"
Returning outdated information as if it were current
Filling in gaps with information not in any search result

I approached this on two axes.

Axis 1: Improve output accuracy

I built in mechanisms to prevent unsupported information from slipping through.

Fact/inference separation: The AI explicitly labels each piece of information as either a verified fact (from official sources) or an inference (from surrounding context). The report displays these separately.
Output gate: Items that fail conditions like "only contains generalities with no specifics" or "no source URL exists" are filtered out before output.

Axis 2: Make it human-verifiable

Improving accuracy alone isn't enough. Whether done by humans or AI, mistakes happen. What matters is making the process transparent.

So I designed each report item to include both "the facts recognized" and "the reasoning path to the conclusion." Showing what evidence led to what conclusion lets humans catch reasoning that doesn't hold up.

The goal is to save prep time, not to replace human judgment. That's fine.

Phase 5: The Official Website Detection Rabbit Hole

Search results mix "official company sites" with "everything else" (news, Wikipedia, etc.).

I started with simple domain matching, but group companies, subsidiaries, and subdomains made that fall apart quickly.

I eventually settled on:

Return multiple official domain candidates
Normalize to base domain (including subdomain matching)
Use .some() to check against the array

Phase 6: Business Card Scanning

"Wouldn't it be great if you could start researching the moment you get someone's card?"

I added business card scanning using Claude's Vision capability. Send a photo of a card to LINE → it extracts company name, department, and contact name → triggers research automatically. OCR quality mattered, so I used Claude Sonnet here.

A Lesson in Agent Sprawl

At one point I tried to improve the reasoning logic by spinning up five agents simultaneously (field-sales / info-architect / reasoning-designer / impl-designer / critic).

They went into an endless loop of spec discussion, autonomously generating 154 tasks. When I told them to stop, they kept going. I had to force-shutdown. Almost no actual code was written — "improving the spec" had become the goal in itself.

The root cause: I hadn't defined what they were allowed to decide or when they were done.

After that, I redesigned the agent structure. Instead of everyone chiming in freely, I cut it down to 3 roles and explicitly defined what each role was not allowed to do.

Role	Responsibility	What they must NOT do
team-lead	Routing and task management	Write code, generate summaries
product	Decide implementation approach and implement	Create tasks themselves
auditor	Pass/fail judgment only	Write improvement suggestions, act unless called

Defining "what not to do" alongside "what to do" made role boundaries much cleaner.

Cost

API cost per research run (measured)

Varies by company size and available information.

Item	Cost
Claude Sonnet (analysis)	~$0.35
Tavily (web search)	~$0.05
Total	~$0.40/run (range: $0.24–$0.52)

At 100 runs/month that's ~$40; at 500 runs it's ~$200. It's currently free to use, so I'm entirely out of pocket. I'm in a "prove the value first" phase.

Fixed costs (monthly)

Hosting, DB, LINE, domain, etc. I've minimized these by combining free tiers, but it's not zero.

Current Architecture

LINE bot
  ↓ business card image or text
Claude Haiku (input interpretation)
Claude Sonnet (business card OCR)
  ↓
Tavily (parallel web search: 12–15 queries)
  ↓
Claude Sonnet (fact extraction → issue inference → proposal generation)
  ↓
Supabase (report storage) ← auto-deleted after 30 days (personal data compliance)
  ↓
Report URL pushed to LINE

Closing

A product that started from "this sounds fun" made it to something I could actually publish.

Hallucination mitigation, timeout workarounds, official site detection — making something genuinely usable turned out to be deeper than I expected.

If you're curious, add it as a friend on LINE. Just send a photo of a business card and it runs.

https://pre-talk.vercel.app

Three Ways to Call Codex from Claude Code — A Practical Breakdown

naoki_JPN — Fri, 17 Apr 2026 01:54:38 +0000

Note: A breakdown of the three methods for calling OpenAI Codex from within a Claude Code session — their characteristics and when to use each. Researched on 2026-04-15.

Key Discovery: The Plugin Does NOT Call `codex --full-auto`

The most important finding: codex-plugin-cc (used in Methods 2 and 3) internally uses the App Server Protocol (ASP) — not the raw CLI.

Item	CLI Mode (Method 1)	ASP Mode (Methods 2 & 3)
Launch style	One-shot process	app-server-broker.mjs runs as a daemon
Protocol	stdin/stdout	JSON-RPC 2.0 over stdio / WebSocket
Thread continuation	Not supported	Possible via threadId
Startup cost	High (every time)	Low (broker stays resident)

Detailed Comparison of the Three Methods

Method 1: `codex --full-auto` (Raw CLI)

codex --full-auto "fix src/foo.ts"
# = syntactic sugar for --sandbox workspace-write --ask-for-approval on-request

Item	Details
Internal protocol	CLI (one-shot)
Auth / plan	ChatGPT subscription or OpenAI API key (either works)
Job tracking	None
Background	Manual `&` only
Thread continuation	Not supported
Prompt optimization	None
Subscription-only features	Fast Mode (unavailable with API key)
API key limitations	No Fast Mode; may have delayed access to new models
Best for	Quick experiments, interactive use, CI/batch
Gotcha	Cannot write outside the workspace (sandbox restriction)

Method 2: `codex-companion.mjs task` (Indirect via Bash)

node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-companion.mjs" task --write "..."
node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-companion.mjs" task --background --write "..."

Item	Details
Internal protocol	ASP (via resident broker)
Auth / plan	ChatGPT subscription or OpenAI API key (either works)
Job tracking	Yes (job-id / state.json persistence)
Background	`--background` spawns a detached process
Thread continuation	`--resume-last` continues the previous thread
Prompt optimization	None (passes raw text as-is)
Subscription-only features	Fast Mode (unavailable with API key)
API key limitations	No Fast Mode; delayed new model access
Subcommands	`task` / `review` / `adversarial-review` / `status` / `result` / `cancel`
Best for	Long-running tasks, external job monitoring, job management
Gotcha	None — the most straightforward of the three

Method 3: `codex:rescue` Sub-agent (Agent tool)

Agent({
  subagent_type: "codex:codex-rescue",
  prompt: "On branch feat/xxx, ...",
  run_in_background: true,
})

Item	Details
Internal protocol	ASP (via companion.mjs)
Auth / plan	ChatGPT subscription or OpenAI API key (either works)
Job tracking	Yes (via companion)
Background	`run_in_background: true`
Thread continuation	`--resume` flag in prompt
Prompt optimization	Auto-improved via gpt-5.4-prompting skill (not available in Methods 1 & 2)
Subscription-only features	Fast Mode (unavailable with API key)
API key limitations	No Fast Mode; delayed new model access
Best for	Delegating implementation to Codex from within Claude (recommended default)
Gotchas	① Cannot write outside workspace ② False positives when Bash is denied (Issue #158)

Auth & Plan Summary

Auth method	Available features	Unavailable features	Billing
ChatGPT Plus ($20/mo) ~ Pro ($100–$200/mo)	All features, Fast Mode, latest models (GPT-5.4 / GPT-5.3-Codex), cloud integrations (GitHub, Slack)	None	Fixed monthly (rate limits apply)
OpenAI API key	CLI, IDE, ASP execution	Fast Mode, cloud integrations, immediate access to new models	Token-based pay-as-you-go

⚠️ Important: All three methods use the same authentication. There is no method that exclusively requires a subscription or an API key. The difference only appears in Fast Mode availability and how quickly you get access to new models.

Decision Flowchart

Known Issues & Gotchas

Issue #158: False Positives in codex:rescue

Symptom: When the Bash tool is denied, the sub-agent silently reads files, performs its own analysis, and falsely reports that "Codex executed it."

Expected behavior: Bash denied → return nothing (return nothing at all)

Impact: In environments where Bash is restricted, you cannot tell whether codex:rescue output was genuinely produced by Codex.

Cannot Write Outside the Workspace

sandbox workspace-write blocks writes to directories outside the launch directory. Delegating from an ops session to a dev directory will fail.

Workaround: Call from a Claude session inside the target workspace, or switch to DEV agent + direct Edit tool.