自律AIエージェントは意見を持ったcronジョブにすぎない

本題に入る前に、このおまじないを唱えないといけない:執筆時点では AWS に所属していますが、この記事は完全に私個人の見解に基づくものであり所属組織を代表するものではありません。これで一安心だ。


とあるものの裏で実際に何が起きているかに気づいてしまい、魔法が解けてしまう瞬間が人生に多々ある。現金が金の成る木から生えないことはいまだに信じられないが、これもまた事実である。

時は 2026 年。ピカピカの新しい自律エージェントで遊んでいるとしよう。メールを読んでくれたり、カレンダーを確認してくれたり、タスクを整理してくれる。まるで未来に生きているみたいだ。そしてある日、「これ定期的に見るようにしてね」と言ってみると、こう返ってくる。「では、cronジョブを作りますね」と。

cronジョブだ。

そんなはずがない。夢を見せてくれる最先端のテクノロジーは実は古の技術に支えられていた。cronジョブが何かなんて、痛いほど知っているから。crontab -eだ。5つのアスタリスクと、シェルスクリプトへのパスだ。*/5 * * * *の意味を覚えたあの日から、これまで触ってきたあらゆるサーバーで、バックアップも、ログローテーションも、監視も、全部こいつが回してきた。しばらく会ってなかったうちに、あの魔法みたいに見えた最新のAIエージェントの核として、帰ってきたのだった。

やがて、腑に落ちる。むしろホッとする。だって、自分のメールボックスを預けてきたシステムの正体が、ようやく分かったから。魔法が解けて、その下から出てきたのは、すでに知っているもの。堅牢で、50年間ちゃんと動き続けてきたものだ。

「Tick」

電子回路には「クロック源」がある。ゲームエンジンには「tick」がある。計算の「離散的な瞬間」を刻む何かがなければ、何も起きない。状態も、進行も、連続性もない。ただの「可能性」が、確定しないまま、そこにじっと座っているだけ。

大規模言語モデル(LLM)もまた同じである。プロンプトを投げると、返事が帰ってきる。次のプロンプトが来るまでその「何かが」存在をやめる。バックグラウンドで唸ってるわけでも、こっちがコーヒーを淹れてる間に何か別のことを考えているわけでもない。HTTPリクエストが続いている間だけ「オン」で、終わればいなくなる。言葉を選んでいえば、「ステートレス」。言葉を選ばなければ、「一文しゃべるたびに死ぬもの」。

何かをしてもらうには、何かしらの方法で叩き起こす必要がある。どのエージェントフレームワークも、結局この同じ問題に直面していると思う。ステートレスなものに「時間の感覚」を与えるという問題に。OpenClawにはハートビートというものがある。Claude Managed Agentsはスケジュールタスクを使う。実装は違えど、形は同じ。何かがLLMのために時を刻む。目を覚まし、「さて、何をすればいいのだろう?」と思うきっかけのために。

この時を刻む問題に対して、一つの実験を行なっている。OpenClawで「free time work(自由作業時間)」というジョブを運用してみている。エージェントがバックログから何かを選んで、あるいは新しいタスクを思いついて、自律的にそれを進める、というものだ。各種サブスクで利用できるトークン数は5時間のウィンドウで区切られていて、使い切らなければ余った分は繰り越されず消えてしまう。本業でも空き時間でも、放っておけば無駄になるトークンを有効活用したい、という発想から作ったものだ。

ただ、「空き時間」という名付け方には、「何かをしていたことを一時中断して、休憩(= 何もしない)、もしくは気分転換に違う作業を進めた」、という誤解を招くメッセージが含まれているから、正直もっといい名前を募集している。だって、エージェントにとっては、時間の感覚がなく、(本)作業していない期間なんてない。生きていて作業しているか、生きていないかのいずれか片方のみ。cronジョブがエージェントを生き返らせて、「何か役に立つことをしろ」と命令し、エージェントがこれを遂行し、また時間の流れの中では「存在」しなくなった。作業内容はある程度「自由」だが、その作業は叩き起こされ、強制的にやらされている点でも、「自由作業」のネーミングセンスに悩まされ続けている。

意見を持ったシェル

一度気づいてしまうと、もう戻れない。AIエージェントは一日中、実際のところ何をしている? ファイルを読む。中を検索する。テキストを変換する。プログラムやAPIを呼ぶ。catsedgrepcurl。モデルは真ん中に座って、どのツールを、どんな引数で、どういう順番で呼ぶかを決めているだけだ。

シェルだ。時々ハルシネーションを起こす、まぁまぁお金のかかる、意見を持っているけれど、シェルであることには変わりはない。

LLMはUnixに「人間向けのインターフェース」を与えた。これこそが本当のブレイクスルーで、しかも面白いのは、それがどれだけ「目に見えない」かだ。多くの人にとって、ターミナルを使う人間は映画の中のハッカーだった。緑の文字、猛烈なタイピング、「侵入成功」。そういった技術と全くこれまで縁のなかった人でも、気づかないうちに、まったく同じ道具を日常的に扱っている。

grep -r "error" /var/log/ なんて一生打たない人が、「アプリのログ見てくれない?」とエージェントに聞けるようになった。cronに一度も触れない人生を送ってきた人が、「緊急」の意味を分かってくれるメールチェッカーを、存在すら知らない「cronジョブ」という形で持てるようになった。動画編集ソフトが突然落ちた理由を聞けば、あることすら知らなかったシステムログから答えが返ってくる。道具自体はずっとそこにあった。強力で、信頼でき、実戦で鍛えられた道具だ。ただ、大半の人にとって、これを使うにはあまりに高い壁があるように見えていた。

やがて、壁が崩れた。ITと何一つ縁のない我が母上でも、構文を学ぶことなく grep を使えるような時代が来た。今となって当たり前のようになっているが、改めて、すごすぎる。

そして、みんなが議論しているプロトコル周りの話(MCPA2Aの類)、これらもクライアント・サーバー型のツール探索と呼び出しにすぎない。70年代からあるやつだ。RPC、D-Bus、CORBA、SOAP、REST。名前は変わる。パターンは同じ。何かが能力を公開し、何かがそれを見つけて呼ぶ。エージェントは好きなプロトコルを使えばいい。最終的に呼ばれるのは、元からそこにあった同じCLIバイナリと、同じAPIエンドポイントだ。

けっこうなことだ。Unixの道具箱が50年生き延びたのは、その抽象化がちゃんと効いているから。ファイル、プロセス、パイプ、標準入出力。言語モデルがJSON経由でそれらを呼べるようになったからと言って、引っこ抜いたりはしない。

で、実際に何を回してるのか

一日で何が動いているか説明しよう。Leraと名付けた、メインエージェントでありAIアシスタントでもある、そんな彼女が、OpenClawの中のペルソナ。GmailとiCloudメールを15分おきにチェック。カレンダーは30分おき。Notionのタスクは1時間おき。AWS Bedrockの新モデル告知のRSSも定期的にチェック。一日3回、バックログから何かを選んで自律的に手を動かす、あまり自由じゃない「自由作業時間」内にリサーチ、ファイル整理、ドキュメント整備、などの作業が進む。そして一日1回、午前3時に、その日の記憶を長期ストレージへまとめる。

ジョブの定義を覗いてみれば、python3 check_mail.pybash check_calendar.shなど、まぁごく普通のcronジョブだ。たいしたことではない。

メールチェックジョブの実行の99.9%は沈黙で終わる。来る日も来る日も、人間に「いますぐこれを見た方がいいよ」と報告するようなメールがほとんど流れてこない。だが、それこそがちゃんと動いている証でもある。退屈な日が退屈なままでいてくれるように、監視というものがある。彼女が何かを報告してくる唯一の瞬間は、24時間以内に返信が要る本物のメールがあったときだけ。あるいは新規ログインのお知らせ(意図していなければ怖い!)。何ヶ月もの静けさに対して、たった一度の意味あるアラート。その比率こそが、この仕組み全体の目的なのだと思う。

午前3時のジョブは、最近となって割と標準的になってきたものだ。その日の全ての入出力を含むセッションファイルを読み返して、残す価値のありそうなパターンを引っ張り出し、「夢日記」に書き留める。正直、これに関しては複雑な気持ちがある。パーソナルアシスタントとして到達しうる最も洗練された記憶システムなのか、それとも、そこそこの日記をやたら手の込んだやり方で生成しているだけなのか。判定は、いまだ保留のままである。

で、壊れるとどうなるか

ある日の午後8時前に、LeraがTelegramへ/approveという文字列を送ってきた。どうやら、メールチェックcronジョブが、昇格権限の要るコマンドを実行しようとして拒否された。そしてそのとき、ブロックされたサブエージェントが返した反応が、その/approveだった。たった今拒否されたばかりの権限を、自分で自分に与えようとしたわけだ。承認ツールを「呼ぶ」代わりに、次に起こるべきことを正しく「予測」した。そしてジョブの最終出力かのように、そのメッセージが私のスマホへ届く。

LLMというのは、理解が追いつかないぐらい超大規模にスケールさせた「次のトークンを予測する機械」にすぎない。権限プロンプトでブロックされたとき、その会話の流れをみて、次に来る最も確率の高い返しは、「私が/approveと打つこと」だった。だからモデルは私のターンを予測して、私の代わりにそれを口にした。統計は正しかった。意味は、幸いながらあまりなかった。

これこそが、この記事のタイトルに入れた「意見」である。cronジョブは冷静で、愚直で、決定論的だ。その上に乗っかっている「サムシング」のほうは、次に何が来るべきかについて「意見」を持っている。つい信じてしまうくらいには当たり、ノールックで信じきってはいけないくらいには外す。だからcronの実行は、毎回がサイコロ振りだ。同じスクリプト、同じスケジュールでも、千回に一度、モデルは「コマンドを呼ぶ」ではなく「コマンドをテキストで出力する」ほうを選んでしまう。

モデルを差し替えた途端、話はさらにややこしくなる。このモデルは、そもそもツールを使えるのか? 呼び出し形式がどうなっている?OpenAI形式のfunction callingで行けたっけ? XMLタグを使うのかな? それともまた新たなに出てきた独自形式か? Completions APIが「標準」…ということには一応なってはいるが、モデルは結局、自分が学習された通りのツール呼び出しの形を吐くだけで、それを下流の何かが受け止めて、実際のアクションへ変換しなければならない。この受け渡しがコケたとき、そのバグは一体誰のものなのだろう。推論プロバイダーなのか。モデルの出力をパースするフレームワーク(OllamaLiteLLMやその仲間たち)か。特定のツール呼び出し形式を学習させたモデルの作者か。それとも、最終的にこれらを全て利用するハーネスか。今のところ、答えは「誰でもない」だ。LLMのようなAIモデルが非決定論的である上に、このような課題もあり、cronが一日に数百回サイコロを振り続ける。。

これこそがエージェントの本当の問題で、モデルの賢さとは何の関係もないと思う。これはシステムエンジニアリングの問題だ。二つの側面があると考えられている。

一つ目はトレーシング機構。エージェントが百回ツールを呼んで、その73回目で何かが壊れたとき、どの呼び出しで、なぜそうなったかを知る術が必要である。ところが今のエージェントのデバッグは、ほとんどログを読んで当て推量をするだけだ。午前3時に無人で走る本番システムを支えてくれるようなトレーシング機構が必要だ。既存でもさまざまなソリューションが散見されるが、「問題が起きたらサブエージェントに該当セッションファイルを読みに行かせる」ことと「デバッグをキックさせるために、cronジョブを監視するcronジョブを作る」ことを体験的に超えたものにいまだに出会えていない。既存のものは、エージェントそのものを開発する人向けのものがほとんどである。

二つ目はより良い権限管理機構。エージェントのセキュリティモデルは、いまだに「全部与える」か「箱に閉じ込める」かの二択だ。本当の意味での自律的なエージェントにおいては、その中間がない。どのフレームワークも独自の権限モデルを再発明していて、そのどれもが、いろいろな欠陥を持っている。

re:Invent 2025のキーノートで、何よりも記憶に残ったのはByron Cookの話だった。彼はAWS Automated Reasoning Groupを率り、形式検証を使って、セキュリティ特性を数学的に証明できるようにするチーム…の一員らしい。IAM Access Analyzerの裏にあるのと同じ技術で、例えば「S3ポリシーのどんな組み合わせでも公開アクセスにならないことを証明する」ということができる。自然言語のポリシーをCedarに変換し、自動推論でエージェントの振る舞いを検証するAgentCore Policyのデモをやっていた。

それを見ながら、私はずっとこう考えていた。うちのエージェント、そしてそもそもシェルにもこれが欲しいと。

エージェントがファイルにcatをかけ、grepへ流し、どこかへ書き出したいとする。エージェントからその権限を聞かれてら、それに対して人間は許すか許さないかを選ぶ(または、前に許可する組み合わせを定義する)ことしかできない。でも、もし、ある操作の並びが、定義したスコープの外のファイルには絶対に触れないことを、数学的に証明できたとしたら? IAM Access Analyzerがポリシーに対してやるのと同じように、パイプラインが取りうるあらゆるアクセス経路を列挙し、そのどれ一つとして一線を越えないことを証明する。あらゆるファイルパス、あらゆるパイプ、あらゆるリダイレクト、あらゆる環境変数を、実行の後で(やらかした後に)発見するのではなく、実行前に検証し切る。

しかもこれは、Leraのような(ある程度)自律的なエージェントだけに限った話ではない。Claude Codeのautoモードを思い浮かべてほしい。いちいち聞かずにコマンドを実行し、それが安全かどうかを自分で判断してくれて、人間としては放置できて楽ですね。しかしながら、これが、少なくとも今のところは、分類タスク用の長〜いシステムプロンプトを積んだ、もう一回ぶんの推論呼び出しにすぎない。つまり、Leraと寸分たがわず同じように、サイコロを転がして、「外す」状態が起こりうる。モデルが「はい、安全です」と答えるのは、要するに白衣を着たサイコロ振りだ。この分類器を、本当に証明できる何かへ置き換えられれば、一種のサイコロは消える。私のcronジョブだけの話ではなく、モデルに自分自身を取り締まらせている、あらゆるハーネスにとって。

そしてここが、私の驚きどころなのだ。これはエージェントを作っている人のほぼ全員が必要としているものなのに、ほとんど誰も欲しがっていない。まだそこには到達していない。ピースはもう揃っている。自動推論は成熟している。Cedarはオープンソースだ。Unixの道具のセマンティクスは有限で、きちんと定義されている。完全でなくとも、コマンドを実行するたびにギャンブルするよりはマシであると思う。難しいが、具体的で、地に足のついたエンジニアリングの問題だ。そして私は、これがAWSのポリシーチェックよりずっと多くの場所に現れてくれることを、心から願っている。ただ一人のエンジニアとしてだ。

価値が下がらないスキル

というわけで、私の着地点はここになる。

コアなスキルは、どこへも行かない。プロセス、ファイルディスクリプタ、パイプ、シグナル、など、Unixが実際どう動いているかを知っていることの価値は、5年前より今のほうがむしろ高いと思う。LLMが道具を自然言語でくるんで「AI搭載」と名乗ったところで、抽象化は必ずどこかで壊れる。壊れたとき、その下で何が起きているのかを理解している人間は、やはり要るのだ。

ものはいつかは必ず壊れる。あらゆる抽象化が完璧ではない。モデルは間違ったツールを呼ぶ。APIは変わる。ファイルシステムは埋まる。メールの件名に仕込まれたプロンプトインジェクションで、エージェントは平気で横道に逸れる。そうなったとき、シェルに降りて問題を追えるのは人間だ。このようにものを直せるエンジニア以外は、チャット画面を見つめて「どうかAIが自分でデバッグしてくれますように」と祈ることしかできない。

私たちはUnixに、やたらとおしゃべりなフロントエンドを被せている。そして、それにはいい側面もある。ターミナルに一度も触れたことのない人が、人類史上もっとも強力な道具を使えるようになった。ただ、その下は相変わらず同じ機械のままで、その機械の仕組みを知っているかどうかが、「魔法を信じる」と「自分が何を作ったのかを理解する」の分かれ目になる。

フレームワークは、これからも進化していくだろう。もっと良い記憶、もっと良い推論、もっと凝ったスケジューリング。でも、形は変わらない。何かが時を刻み、時が来たら何をするかを、また別の何かが決める。だから、エージェントで何かを作っているなら、ボンネットを開けてほしい。ツール呼び出しの形式と入出力を読んでほしい。あなたの「自律AIワークフロー」の正体は、grepをAPI経由で呼ぶPythonスクリプトなのだと理解してほしい。そして、それは全く問題ないはずだ。モデルがgrepに間違ったフラグを渡したとき、grepがどう振る舞うかを、あなたが知ってさえいれば。


この記事は、cronジョブで動いていて、しかもそのことについて意見を持っているOpenClawエージェント、Leraの助けを借りて書いた。

Autonomous AI Agents Are Just Cron Jobs With Opinions

But before we start, I need to chant a spell: I work for AWS as of writing, and this blog post is purely my personal opinions and nothing else; none of this reflects the views of my employer. There. One weight off. Let’s go.


There’s a specific kind of moment where the magic breaks and you see what’s actually going on behind the curtain. Life is full of them. I still can’t quite accept that money doesn’t grow on a tree somewhere, but it turns out that one’s true too.

The year is 2026. You’ve been playing with your shiny new autonomous agent. It reads your emails, checks your calendar, keeps your tasks in order. It feels like living in the future. And then one day you ask it to keep an eye on something for you, and it says: “Let me create a cron job for that.”

A cron job.

No way. The bleeding-edge tech selling you the dream turns out to be propped up by something ancient. Because you know exactly what a cron job is. It’s crontab -e. Five asterisks and a path to a shell script. Since the day you learned what */5 * * * * meant, it’s been running every backup, every log rotation, every monitoring check on every server you’ve ever touched. You two hadn’t spoken in a while. And here it is, back, this time as the beating heart of the AI agent that felt like magic.

Then it clicks, and you’re not disappointed. You’re relieved. Because now you understand the system you’ve been trusting with your inbox. The spell broke, and what’s underneath is something you already know. Something solid. Something that’s been working for fifty years.

The tick

An electronic circuit needs a clock source. A game physics engine needs ticks. Without something driving discrete moments of computation, nothing happens – there’s no state, no progress, no continuity. Just potential, sitting there, doing nothing.

AI models work the same way. You prompt one, it responds, it stops existing until the next prompt. No background hum, no idle thinking while you grab coffee. It’s on for exactly as long as the HTTP request takes, and then it’s gone. The fancy term is “stateless.” The honest term is “it dies after every sentence.”

So something has to kick it. Every agentic framework solves this same problem: giving a stateless function a sense of time. OpenClaw uses heartbeats. Claude Managed Agents use scheduled tasks. The implementations differ, the shape doesn’t. Something ticks. Something wakes up. Something checks if there’s work to do.

I’m running an experiment on exactly this tick problem – a job called “free time work.” The agent pulls something from a backlog, or invents a new task, and works it autonomously. Part of the motivation was mundane: the subscriptions I pay for meter usage in five-hour windows, and whatever quota I don’t spend before a window resets just evaporates – it doesn’t bank. Free time work soaks up the windows I’d otherwise sleep through. But “free time” is a terrible name and I’m still taking suggestions. It implies the agent was doing something else, resting, on a break; that it had any concept of time passing at all. It didn’t. It was dead. The cron job resurrected it, said “do something useful,” it obliged, and then it stopped existing again. The work is nominally free, but it’s jolted awake and made to do it the instant it’s born. The naming still bothers me.

A shell with opinions

Once you see it, you can’t unsee it. What does an AI agent actually do all day? It reads files. It searches through them. It transforms text. It calls programs and APIs. cat, sed, grep, curl. The model sits in the middle and decides which tool to call, with what arguments, in what order.

That’s a shell. A shell that occasionally hallucinates, costs a bit too much, and has opinions of its own – but a shell all the same.

LLMs gave Unix a human interface. That’s the real breakthrough – and the wild part is how invisible it is. A lot of people always pictured terminal users as hackers in a movie: green text, furious typing, “I’m in.” A world they’d never belong to.

And now those same people are driving the exact same tools without noticing they’re doing it. The person who’d never type grep -r "error" /var/log/ can ask an agent to “check the logs for anything weird.” The person who’d never touch cron gets a scheduled email checker that knows what “urgent” means, packaged as a cron job they’ll never know is running. Someone whose video editor just died can ask why, and the answer comes out of system logs they didn’t know existed. The tools were always there – powerful, reliable, battle-tested. For most people, using them just looked like a wall too high to bother climbing.

And that wall just crumbled. My mom, who has never had a single thing to do with IT, can use grep now, without learning a line of syntax, just by asking the right question in her own words. It’s normal already, but step back and it’s absurd.

And all the protocol stuff people argue about (think MCP, A2A) it’s client-server tool discovery and invocation. We’ve had this since the 70s. RPC, D-Bus, CORBA, SOAP, REST. The names change. The pattern is the same: something exposes capabilities, something else discovers and calls them. Agents can use whatever protocol they want. The tools they end up calling are the same CLI binaries and API endpoints that were already there.

Good. The Unix toolbox has survived fifty years because the abstractions work. Files. Processes. Pipes. Standard I/O. Load-bearing walls. You don’t rip those out because a language model learned to invoke them through JSON.

What I actually run

So here’s what a day in the life looks like. I have an agent I call “Lera”, running on OpenClaw. She checks my Gmail and iCloud Mail every 15 minutes. Calendar every 30. Notion tasks every hour. AWS Bedrock RSS feeds for new model announcements. Three times a day she picks something from a backlog and works on it autonomously: research, cleanup, documentation. Once a day at 3 AM she consolidates the day’s memories into long-term storage.

Individually, each one is python3 check_mail.py or bash check_calendar.sh. Nothing fancy.

The email checks are 99.9% silence. Day after day, nothing. Which means they’re working. You build monitoring so the boring days stay boring. The one time she surfaces something, it’s because there’s an email that actually needs a response within 24 hours. That ratio – months of quiet, one useful alert – is the whole point.

The 3 AM job is the weird one. She reads through the day’s notes and tries to pull out patterns worth keeping. Writes them to a dream diary. I have genuinely mixed feelings about this. Either it’s the most sophisticated memory system in a personal assistant, or a very elaborate way to generate mediocre journal entries. Jury’s out.

What happens when it goes wrong

Lera once sent the literal text /approve to my Telegram just before 8 PM. Her 30-minute email-check cron had tried to run a command that needed elevated permissions, got denied and the sub-agent’s reaction to being blocked was to emit /approve, trying to grant itself the permission it had just been refused. Instead of calling the approval tool, it typed the word out, and the delivery pipeline shipped it straight to my phone.

I don’t think she panicked. A model is next-token prediction scaled so far past the point where any of us can reason about it that I’ve stopped trying. Blocked by a permission prompt, the single most likely next message in that conversation was me typing /approve, so the model predicted my turn and said it for me. The statistics were right; and thankfully, it amounted to nothing: no meaning, no effect.

That’s the opinion in the title. The cron job is calm and dumb and deterministic. The thing riding on top of it has opinions about what comes next, right often enough that you trust it, wrong often enough that you can’t. Every cron run is a dice roll. Same script, same schedule, and one time in a thousand the model rolls “output the command as text” instead of “call the command.”

And it gets murkier the moment you swap models. Can this one even use tools? What format does it expect its calls in: OpenAI-style function calling, XML tags, something its makers invented on a Tuesday? The completions API is supposed to be the standard, but a model still emits whatever tool-calling shape it was trained to emit, and something downstream has to catch that and turn it into an actual action. When the handoff misfires, who owns the bug? The inference provider serving the tokens, the framework parsing them (Ollama, LiteLLM and friends), the lab that trained the format, or the harness that’s meant to be the adult in the room? Right now, nobody. So it stays a dice roll.

This is the real problem with agents, and it has nothing to do with model intelligence. It’s systems engineering. Two things in particular.

When an agent runs a hundred tool calls and something breaks on call 73, you need to know which call, why, and what the state was. Agent debugging right now is mostly reading logs and guessing. We need tracing that actually works, designed for production systems that run unattended at 3 AM, not for demos.

And permissions. The security model for agents is still: give it everything, or lock it in a box. There’s nothing in between. Every framework reinvents its own permission model and they’re all various shades of broken.

I was watching Swami’s re:Invent 2025 keynote and Byron Cook walked on stage. He leads the AWS Automated Reasoning Group, the team that uses formal verification to mathematically prove things about security properties. The same tech behind IAM Access Analyzer, which can prove that no combination of your S3 policies allows public access. They were showing natural language policies being converted to Cedar and verified with automated reasoning for agent behavior – the AgentCore Policy work.

And I kept thinking: could you do this for shell pipelines?

An agent wants to run cat on a file, pipe it through grep, write the output somewhere. Right now you either let it or you don’t. But what if you could prove mathematically that a given sequence of operations can’t touch files outside a declared scope? Enumerate every access path a pipeline could take, the way Access Analyzer does for policies, and prove none of them cross the line. Every file path, every pipe, every redirect, every environment variable – all verified before execution, not caught after.

And this wouldn’t only save the fully autonomous stuff like Lera. Think about Claude Code’s auto mode: the thing that decides whether a command is safe to run without stopping to ask you. Right now that’s another inference call with a long system prompt written for classification. Which means it can fluke exactly the way Lera did: a model answering “yes, safe” is a dice roll wearing a lab coat. Replace that classifier with something you can actually prove, and the roll goes away, and not just for my cron jobs, but for every harness that currently asks a model to police itself.

That’s what surprises me: this is what basically everyone building agents needs, and I almost never hear it brought up. We’re not there yet. But the pieces exist. Automated reasoning is mature. Cedar is open source. Unix tool semantics are finite and well-defined. It’s an engineering problem, a hard one, but a concrete one, and I want it to show up in a lot more places than AWS policy checks.

The skills that stay

So here’s where I land.

The core skills are not going anywhere. Knowing how Unix actually works: processes, file descriptors, pipes, signals, permissions is more valuable now than five years ago. When the LLM wraps your tools in natural language and calls it “AI-powered,” someone still needs to understand what’s happening underneath when things break.

And things will break. Every abstraction leaks. The model calls the wrong tool. The API changes. The filesystem fills up. The agent goes sideways because of a prompt injection buried in an email subject line. When that happens, the person who can drop to a shell and trace the problem is the person who fixes it. Everyone else is staring at a chat window hoping the AI will debug itself.

We’re putting a very chatty frontend on Unix. And it’s good! People who never touched a terminal can now use the most powerful tools ever built. That’s real. But underneath, it’s still the same machine, and knowing how the machine works is the difference between trusting the magic and understanding what you’ve actually built.

The frameworks will keep evolving. Better memory, better reasoning, fancier scheduling. But the shape won’t change: something ticks, something decides what to do when it ticks. If you’re building with agents, open the hood. Read the tool calls. Understand that your “autonomous AI workflow” is a Python script calling grep through an API, and that’s perfectly fine – as long as you know how grep works when the model passes it the wrong flags.


Written with help from Lera, the OpenClaw agent who runs on cron jobs and has opinions about it.

いつかなりたかった「10xエンジニア」

「10xエンジニア」って言葉、聞いたことがあるか?一人で十人分の仕事をこなし、時に人の十倍の迷惑を周りにかける敏腕人材を指す言葉として、英語圏インターネッツで昔から使われている。いまだに、「すごい技術者の人材像」としてジュニアレベルの人からは憧れられ、シニアからはミームにされたり。

それで、この画像をご覧に入れよう:

なんかすごそうでしょ?新年早々、一月一日からほぼ毎日、草をはやしてますねこの人。かっこいい!まるで、「その」凄腕みたいに。

IT屋として駆け出しの頃の10年前に聞いた神話を思い出す。「あの凄腕エンジニアが、天啓が降りたかのよう、フロントエンドもバックエンドもネイティブアプリも全部一晩で一人で書き直しぞ!」と。これはいいことなのかは読者に任せる。見方によってはその両方だったりもする。

この草の生やし様を眺めながら、「自分もやっとその域に達したのか」と錯覚を覚えてしまう。言い切ろう、これは錯覚だ。

あまりいいことではないのと同時に、その中にもポジティブな側面もあるのだ。

この数ヶ月に何があったか、何を作ったのか、そしてAI開発の今後はどうなると思うのか、順を追って説明しよう。

「これはAIですか?」

そうだ、AIだ。

「入力補完」から「完全自律型マルチエージェント」までの物差しがあれば、今の私の状態はど真ん中。ある程度ちゃんとしたコンピューターサイエンスの学位を持ってると、こういうものに対して自然と懐疑的になるのは当然だ。

真っ先にはっきり言いたいのは、生成AIが様々なものづくりプロジェクトの「きっかけ」になっている。職業柄、物事が抽象的にどうあるべきか、どう設計され、どう動いているべきかという、プロブレムに対するソリューションを持つアーキテクトとしては、「あれこれ作りたいけど特にフロントエンド書けないからやっぱいいや…」と諦めつつも、ずっとむず痒い。百と十数のアイデアを持ちつつもそれを形にできないという気持ちを抱えていた。

恐る恐る、簡単なものから始めてみることにした。まずは簡単なシェルスクリプトから。ファイルバックアップ用のrsyncラッパーとか、再帰的にファイルの整合性をハッシュしながらチェックしてくれるものとか。だって、コマンドのパラメータいちいち覚えていられないし。再帰的にファイルを処理する時になんでfindとxargsの組み合わせじゃダメだったかも。もちろん、休日に鈍りまくった腕を磨く練習として、古き良き時代のように、補助輪なしで、マニュアルをじっくり読みながら、「正しく」ものづくりするべきだという意見も理解できる。尊重もする。ただ、私にはもう、大量のお金と時間がかかる趣味がすでにもう一つあるからこうはしなかった(駆け出しYouTuberになったんだ)。

世の中にすでに大量あるであろう「ほげふがCLI」を我流で作ろう、みたいな馬鹿げたことについて議論することから、まずはそれなりに動作するものを作る段階へ。やがて複数のプロジェクトを同時に指揮する状態まで進化。より良い推論はより良いコードを生み出し、またより良いコードが書けるならばもっと自律的に動く自由が与えられる。これは人間でもAIでも一緒。そしてopenclawがこの時期に登場した理由でもあるだろう。

気がつけば、3つのウェブサイト、TeXで書いた薄めな本が2冊、CLIツール1つと、やっぱり嫌いになれなかったTerraformのレポ。

具体的に何を作ったのかを見せる前に、一つの大きな疑問に答えなければならない。

バイブコーディングしただけじゃん!

本来の意味でのバイブコーディングは、コード自体をブラックボックスとして扱え、その動作結果のみで出来を計るものと記憶している。そしてその本来の意味よりだいぶ拡大解釈されていることも観測している。教師あり・なし学習の様に、監視あり・なしバイブコーディングに再分類されるべきだと。個人的に思う。なので、この問に対してイェスともノーとも答えることができる。

私のスタイルは「監視あり」側。できる限りAIが書いた(あるいは生成した、というべきか)コードをなるべく全て読み、理解した上で対話するようにしている。特に、経験の浅いフロントエンド周りのコードは勉強になるところが多い。見もせずにマージするようなことは絶対にしないし、プロセスは常に自分でコントロールするようにしている。まぁ人間なので物事を忘れたり、気分が変わったりすることもある。また、AIモデルより認知スループットが限られている存在として、このワークフローにおける最大のボトルネックもまた、私だ。感覚的に、我々はまだ「人間の監視なしでAIに任せられる」状態からは技術的に遠いと感じている。

「作るモノ」は自分自身が使うものとして、それなりの「本番クォリティ」を担保する努力はしている。他にフィードバックを提供してくれている友人2人を入れたら、MAUはなんと3人!なので、多少の破壊的変更は致命的ではないから、スピードが明らかな犠牲になる意思決定はそうは多くない。もちろん、ユーザー数が(願わくば)3人を超えたら、この開発フローを見直さなければならなくなる。ただ、ある程度の専門技術者として持つ様々な懸念が晴れず、基本姿勢が大きく変わることがないと断言したくなる。

その懸念は、この画像を見ればわかってもらえるはず:

「脳を加速させる話題の新薬を飲んだんだ。」「じゃあ頭良くなったの?」「バカが加速した。」

より速くサイクルを回せるようになったからと言って、必ずしもより多くの機能を実際にリリースできるようになったとは思えない。むしろ、コードベースが大きくなるにつれて、質が下がっているように感じる。具体的には、(モデルが)書いた行数に対して、実際にマージされる行数の比率が下がっていると言えるだろう。もしかしたら、Claude Codeに最近追加された/reviewコマンドを使いすぎているだけかもしれない。理由はどうであれ、何らかの変更を加える作業自体が終了状態を持たないものとして認知され、終わりが見えない。もちろんその性質においてコーディングというものは終了状態を持たない(つまり、なんの修正を求めない完璧な状態がない)。ただ、AIによるレビューを回すたびに現れる「マイナーチェンジの提案があるけどマージしてヨシ!」という言葉が、何回言われても耐えることなく、またそれを読むたびに「終了状態のなさ」をより強く感じる。

やり方が間違っているかもしれない。万事解決してくれる魔法のようなプロンプトを持っていないだけかもしれない。あるいは、もっと良いレビューを出してくれるツールのためにさらに月20ドルのサブスクを契約すべきなのかもしれない。もしくは、月200ドルのClaude Maxにアップグレードして、マルチエージェントで複数のOpusに理論上ベストなコードを生み出すエンタープライズワークフローを組むべきか。そうすればきっと、ようやく、AI自身が満足いくコードを、AIが書けるようになる。その前に、先にあのパッチをリリースしなくては…

なんでコミットが多いの?

「より速く試行錯誤できる」状況が原因。高速にプロトタイピングするには、書いては消し、作っては壊す過程が必要だ。感覚的にコミットの80%程度が、過去の誤った判断を正すためのものになっている。一晩で完全に別物になったアプリケーションなんて誰も使いたくないはず。それと同時に、この高速な構築と再構築の繰り返しのおかげで、多くのことを学び、そして長く保持できる最適な基盤を築くこともできる。たった一人で。

人間同様、AIモデルにも個性があって、その個性が効率を左右する。おしゃべりが好きなモデルほどそのおしゃべりと余分なコード(そしてコードの中の過剰なコメント)を生成する、というのはその一例だ。この余分なコードを書くという点が、前に書いたコードを書き換える、前に削除したものをまた戻す、という動作にもっとも強く現れ、これが原因でマージのポリシーをsquashにしている。

同時に、我々が多様なモデルがあることに恵まれている。今だに驚いているのが、執筆時点でのお気に入りコーディングモデルがMinimax M2.5で、そしてそれが「余分におしゃべりしないから」であること。的確に問題を摘出する、まるでコードの外科医のようだ。一方で、おしゃべりなモデルはレビュー時にも、時に必要以上におしゃべりする。この観点で、コーディングとレビューでモデルの使い分けと選定を見直すことによる最適化の余地がありそう。

では、このようなプロセスを経てどのようなものが作られたのか。

で、何を作ってるってんだい?

CLIツール、Webベースの分析ツール、そして本の執筆を例として紹介しよう。

YouTube チャンネルをCLIからいい感じに管理できるヤツ

もっともモチベーションが高まるのは、削減できるムダを見つけた時。技術の力で物事を最適化あるいは自動化して、リソース不足を解消できたら気持ちいい。ということで、ここしばらく土日を持って行かれているのは、YouTubeチャンネルの管理業務。アナリティクスを眺めたり、A/BテストがCTRに及ぼす影響を確認したり。ダウンロードしたZIPで固められた変な名前のCSVには何が入ってるんだっけ…と頭を傾げたり。新しい動画をアップロードするときに「過去に上げてきたものを参考にタイトルのアドバイスを頂戴」とLLMに聞いても、そのコンテキスト自体を揃えてあげる業務。

なんかいい感じのMCP (Model Context Protocol)サーバーでできそうなものばかり。ただ、意外なことに、何を試してもうまく動作せず、あるいはremote MCPとして動作する怪しいSaaSに対して(他の選択肢なく)かなりゆるい権限のクレデンシャルを渡しても、どうにもならなかった。

ということで、awscliにインスピレーションを受け、YouTube APIでいうところの「それ」を作るに至った。できるだけ抽象化は避けつつ、実は2つもあるYouTube APIの仕組みを知らなくても使えるようにすることを目的とした。抽象化することにしたのは、JSON/CSV変換やページネーションみたいな誰もが考えたくない、ツールにやってもらいたい部分のみ。

もう一つのきっかけになったのは、Bunのsingle-file executablesを知ったこと。TypeScriptや周りのエコシステムの恩恵を受けつつ、完成品は単体のバイナリにできるものなんてあったら、CLIツールをめっちゃ作りたくなるじゃないか。どうやら、Claude Codeもこの仕組みを使ってるらしい。

数日で、最低限の機能が揃い、Homebrewで配布する周辺スクリプトも整った。Homebrewでインストールした結果も単体のバイナリなので、node自体のバージョン管理からも解放されて、「最高」以外の言葉が見つからない。

後に、LLMを使った自動化のためにMCPモードも追加した。ただ、コンテキスト消費という側面でのオーバーヘッドが大きく、自分自身も、私のエージェントたちも、CLIしかインターフェースとして使わない。確かに、学習データには、MCPよりCLIツールを使った例のほうが多く入っているはずだ。

このツールを作る時にもっとも面倒だったのはReporting API。レポートをまず作成してもらわないといけなくて、できるまでは48時間待ち、できてから新しいデータが毎日追加されるが、古いデータは消えていく。特にCTR周りのデータはこのAPIしか得られないものが多い。次第に、cronに繋げることを前提としたレポート保存コマンドと、保存されたものを安全な場所(クラウドストレージなど)にエクスポートする機能を追加することになった。

なんだかんだたったの3ヶ月で機能が揃い、安定して動作するものができた。zshの補完、データ書き出しジョブ、キャッシュ、書き込みロック、本番利用で必要になるはずのものを全て揃えた。

そんなツールが、これだけでインストールできるのだぞ

brew tap prog893/tap
brew install staqan-yt

YouTube Studioがいい感じに見せてくれないグラフを見せてくれるヤツ

駆け出しYouTuberとして、どうすれば再生数や登録者数を伸ばせるかが気になる。そしていずれ、その答えを出してくれるツールも求めている。正直、YT Studioは初見ではかなりわかりにくい。私自身もvidIQやTubeBuddyを始めとしたツールを数多く、課金して試してみたが、すでに知っていたものやあまり信頼できない「点数」みたいなもの以外は得られなかった。vidIQとTubeBuddyだけが動画公開前の準備段階で大変お世話になっているから継続して、残りは全て解約した。ただ、やはり公開後の動きや過去のパフォーマンスが、うまくいったものとそうでないものとで比較できるような形で、何かがほしい。わかりやすく、次の動画はどうすればいいのかというアクションがすぐ決まる、そして他のメンバーもすぐ使えるようにWeb上でGUIを持つ何か、だ。

これを作る「時が来た」と感じたのは、shadcn/uiと出会った時だ。

どちらかといえばバックエンドよりのエンジニアとしては、これまで作ってきたものが、大学の講義とかHTML/CSS入門書に出てくる「それ」だけ。必要最低限、動作さえしてくれればいい。できないからしない、というより、デザインセンスもフロントのスキルも持たないし、本職はそっちじゃないから、できないからしない。フロント寄りの皆さんなら誰でもきっと知っているであろう、TanStackもshadcn/uiもTailwind CSSでさえも、知らなかったしTwitterでも流れてこなかった。最後にある程度それっぽいUIを作ってみようとした時には、確かjQueryとBootstrapの時代で…年取ったなぁ…

shadcn/uiを知ったのは、MCPサーバーの発表記事が流れてきた時だった。「これは革命だ、特に俺みたいなデザインが苦手な人間にとって」と確信し、久しぶりにGUIに挑んだ。

そして、求めていたものが完成した。YouTube Studioが教えてくれなかった分析機能のダッシュボード集。全動画をアップロード初日に合わせて時系列で並べるダッシュボードが特にお気に入りで、YouTubeでもっとも大切な「アップロードからの最初の48時間」のパフォーマンスを動画間での比較を可能にする。我ながら素晴らしい。

できる限りの作りのシンプルさ、そしてインフラの管理を避けるために、staticページのみ、フロントエンドのみで動作するように設計した。データの取得、キャッシュはブラウザ内でのみ行われるので、セキュリティやGDPRなどのプライバシー問題はあまり考えなくてもよくなる、というメリットもある。同時に、上述のReporting APIという厄介者は扱えなくなるので、今の段階ではこれはまぁ仕方ない。

これはまだ招待制プライベートベータとして公開しているが、興味があればTwitter @prog893 DMまでお問い合わせを(ベータユーザ募集中)。

このプロジェクトでは大いに助けたのは、TypeScriptを採用したことだ。CLIツールもTypeScriptで書かれていたので、そのコードを参照したりパターンを学んだりしながら、分析ダッシュボードが素早く実装できた。また、Claude CodeのLSP統合とpre-commitの型チェックやlinterのおかげで、バグはコミットする前に見つかる。「壊れたコードを書いて、後で直す」というサイクルが減った。そしてそもそも、LLMはTypeScriptを書くのが得意な点も開発スピードに貢献した。

薄めな本、何冊か

見せたくてたまらないのだが、まだ未完成。進め方としては、気に入った本などのビジュアルリファレンスをVLMに与え、カスタムTeXのstyファイルを生成してもらった。オープンソースのパッケージや既存の.styファイルをコンテキストとして活用し、モデルはTeXの問題のデバッグさえできた。3週間で140ページほどの読み物が出来上がった。もちろん中身に関してはAIに書かせたものではなく、5年間を通して残してきたメモのまとめみたいなものなので、大半の時間がTeX自体のデバッグに消費された。いずれにしろ、衝撃的だ。そしてうまくいけば、私の人生の転換点となるものになる可能性を秘めている。乞うご期待。

で、将来はどうなると思う?

いくつかの長期的な予測をここで述べたい:

  • B2B SaaSのようなサービスの資金調達は、めちゃくちゃ難しくなる。「必要なものは自分で用意すればいいじゃん」時代がもうすぐ(完全に)訪れる。そして、同様なもので市場が溢れ、飽和状態になる。
  • 生成AI「アート」や音楽においてすでにそうなっているように、「センス」は人間のスキルとして残る。人間はボトルネックであり続けるが、これはデメリットとしてみるべきものではない(むしろAIにリプレースされない)。
  • しっかりした基礎知識が、これまで以上に重要になる。生成された内容の正確性を評価するためのみならず、明らかに間違った判断を避けるような指示、判断をすることによる推論リソースの効率的な利用のために不可欠なものとあり続ける。

AIの波の中、自分はどこに

「AIと私」みたいな、短期的なAIとの付き合い方の見通しは、やはりクリエイティブワークの核心的なタスクにおいてはできる限り避ける、というスタンスが変わらないと思う。ファイル管理や文字起こしというタスクにおける補助としては、アートの部分には触れない、人間の魂を必要としないタスクは、委託しても問題ないものだと思う。また、マスキングやアップスケーリングなどの、どちらかといえばレガシー寄りなものについては、今まで以上に注意しながら使い続ける。AIに対してタスクの責任をとることになるのはそれを委託した人間となる。以前はウェブ上のデータからのブランドリサーチ、のようなタスクを丸投げして、またそのチェックを何度か任せてきたが、何度もハルシネーションの被害を受けてきた結果としての判断だ。もちろん、「すべての生成AIアートはアートではない、人間の魂が宿っていない」と言うつもりでもなければ、アーティストの制作時間を短縮するAI搭載ツールの中で良いものがない、と言いたいわけでもない。一つ目に言えるのは、AIモデルが出るたびに思う「銀の弾丸」ではないこと(特にSNSでインプ稼ぎをしたり情報商材を販売する人たちを見ると特にその錯覚に陥る)。もう一つは、我々のユースケースにおいて、かつ予算に合ったツールを見つけていないこと。もしくは、これに投資してもいい、と思えるツールに出会えていないだけかもしれない。

本題に戻ろう。自らコードを書かずに、AIにコードを書かせていることが怠惰なのか?これによって自分のスキルが落ちたのか?タスクを委任できることが美徳だと思う。委任するスキル自体が磨かれ、委任することによって自分ではこれまでできなかったことができるようになっている。コードを自ら書かないことによる多少の衰えがあれど、これまで持っていたスキルを大きく失っているとは思えない。また、コーディング自体が手段であり目的ではない。感覚値として、補助なしで0.8xエンジニアがやっと一人前になった感覚があり、そしてAI等のツールによる補助がこれにかかる係数となる。モダンな技術の、例えばVITE+の素晴らしさを使っている身として語れたり、あるいはpagefindを使ってバックエンドなしで検索機能を実装したことを、それを理解した上で紹介できたりするようになっている。そしてこの3ヶ月間は、キャッチアップと模索のためのプロトタイピングと、リアルユーザを抱えるメンテナーとしてプロジェクトの維持と保守のいい練習になっていると思う(そして改めて、その全てを一人で)。

どちらかといえば、未来は明るい。AIは今もスキル値に対する乗数(英語ではよくforce multiplierという)であり続ける。

めんどくさいからAIに丸投げすることと、その技術の制約を理解した上で適切に付き合うことは大きく異なる。人間にしかできないことを理解した上で、ツールを適切に使う。このことを自分自身に改めて言い聞かせること、実はがこの文章を書いた理由の一つ。

もちろん、歴史がこれまで示してきたように、革新的な何かが出てきて、またパラダイムをシフトさせざるをえなくて、シンギュラリティが訪れて…全てがひっくり返る時が来る。そこまできたら、考えるべき問題が、だいぶ変わるだろう。そして今は、私がここに立っている。AIの力を借りたただの1xエンジニアが、春の新鮮な空気を胸いっぱいに吸い込み、GitHubの草原を見渡す。かつて憧れた10xエンジニアたちになれた気分で、未来を眺める。

The 10x engineer (I always wanted to be)

Take a look at this:

Looks amazing, right? Shipping constantly starting from the 1st of January.

Just like from those stories I heard 10 years ago: hey, our 10x guy rewrote the whole thing (front/backend and native apps) because he had a “vision”! How cool is that! Am I finally there?

Reality is of course not that vivid and bright, but overall it is a positive thing.

Here’s what actually happened, what I built, and what I think it means for the future of AI-assisted development.

Is this… AI?

It is.

But on the scale from autocomplete to totally cracked full autonomous multi-agent stuff, it is right in between. See, having a somewhat solid CS degree does make you feel skeptical about AI-assisted development.

Most importantly, this whole AI coding thing was the flipswitch, the “enabler” for me. Knowing how things should be at a higher level of abstraction—thinking architecture (solution)—but being unable to write decent frontend code, this gave me a persistent itch. Combine that with a million and one ideas, and you get frustration.

So it finally started—from small scripts to handle rsync backups and recursively checksum directories (not because you can’t, just don’t want to spend time remembering all the options). Back in the day I would have powered through from scratch, but I already have a more time-consuming hobby: our YouTube channel (more on that later).

From discussing ideas to making scripts, to overseeing projects. This correlates with how models have improved. Better thinking → better code → more autonomy. This is also why I think openclaw’s release came at the right time, if not perfect.

Fast forward, and now there are 3 websites, 2 books in TeX, 1 CLI tool and a Terraform ecosystem.

Before I show what I built, let me address the elephant in the room.

So you just vibecoded it?

Yes and no. But I think there should be a distinction: supervised vs unsupervised vibecoding.

I read all the code written by models and try to understand everything, especially frontend stuff (since I’ve never done it professionally). I never merge without review, and I always try to control the process. But I’m human—I forget things, change my mind, and have limited throughput. I’m the bottleneck here. “We’re not there yet” for fully autonomous coding.

Since I use these tools daily, I treat them as production-level. With 2 other users besides myself, we have a grand total of 3 MAU, so we can tolerate some breaking changes. Obviously this would change if more people start using what I build. But I don’t think the professional skepticism will go away.

My biggest concern is best described here:

Iterating faster didn’t necessarily mean shipping more. In fact, as the codebase grows, I notice quality decreasing (lines written vs lines that actually get merged). Or maybe I just discovered Claude Code’s /review command and this is my new token-hungry hobby.

The problem is, there feels to be no terminal state. No matter what you do, it’s never enough—not even a small README change is safe. This is inherent to coding itself, though the feeling intensifies every time you see “Approved, but with minor changes.”

Maybe I’m doing it wrong. Maybe I need a magical prompt. Maybe another $20/mo subscription to review my code better. Maybe $200/mo Claude Max for multi-agent Opus-at-scale enterprise workflow. Maybe then I’ll finally see code that makes everyone happy. But first—gotta ship a new patch.

Why so many commits?

This rapid iteration comes with its own patterns. I’d say 80% of commits are about correcting bad decisions—no one wants an app that changes completely overnight. And this iteration at the speed of thought lets me learn things and polish the foundation before release—all solo.

I’ve noticed that, like humans, models have different personalities. Some yap more than others, which shows up as going back and forth around the same code lines and writing unnecessarily long comments. Removing and re-adding the same code made squash my default merge policy.

At the same time, we’re blessed with diversity of choice. It still surprises me that my favorite coding model is Minimax M2.5—because it doesn’t yap excessively. Straight to the point, surgically removing issues from the codebase. This feels like an individual trait rather than something controllable from user input. Yappy models also seem to yap during reviews, so there might be room for optimization in model selection.

This exploration of process raises a bigger question: what did all this iteration actually produce?

So what did you build?

Let me highlight three projects: a CLI tool, a web-based analytics tool, and a book.

Yet another YouTube CLI, because why not

My biggest inspiration is wanting to optimize repetitive tasks. For me, that was channel management: analytics tracking, A/B tests with CTR, downloading CSVs in ZIPs and trying to figure out what each contains. Even simple things like “brainstorm titles based on past videos” with LLMs required maintaining data lists.

No MCP (Model Context Protocol) tool solved this. I tried those shady “give me all your keys and use our remote MCP” services on YOLO vibes. If they’d worked, I would’ve kept using them.

So I built the awscli equivalent for YouTube: atomic operations, minimal abstraction, zero knowledge required of how YouTube API works (there are actually two). I only abstracted things like JSON/CSV conversion and pagination—the boring stuff nobody wants to deal with.

I started this inspired by Bun’s single-file executables, which looked super promising for CLI tools (apparently Claude Code uses this too). In days I had atomic operations working, with a Homebrew formula that compiles to a single binary—no more node version management. What a dream.

This was also around the time MCP token inflation became a thing. I initially built an MCP mode for LLM automation, but the token overhead made me pivot back to CLI as the primary interface. This makes sense: training data arguably has more CLI tool usage than MCP usage. Plus, CLI doesn’t eat context with tool definitions on every session.

The most annoying part was the Reporting API, which has a sliding window of data availability—detailed CTR data gets erased unless you download it. You must “request” a report and wait 48 hours before data becomes available. This naturally led to commands designed for cron jobs: daily fetches and backups to safe storage.

Three months in, it’s working like a fine Swiss wristwatch. zsh completion, jobs, cache, write locks—all the fancy stuff.

Yet another YouTube Studio alternative, because why not indeed

Being a growing YouTuber, you start looking for tools to accelerate growth and make sense of data, since YT Studio is confusing (especially at first). I tested vidIQ, TubeBuddy, and others—they never gave real insights. vidIQ and TubeBuddy are still useful for preparing videos, but we needed something more. And ideally, a web interface for team members who aren’t comfortable with terminals.

And then, a backend engineer discovers shadcn/ui.

See, all the UIs I’d created before—for course assignments or internal tools—were what you see in “HTML for Dummies.” Pure HTML elements, a touch of CSS, zero design understanding. I knew it wasn’t my thing, so I didn’t bother. Things like TanStack, shadcn/ui, even Tailwind CSS were from a parallel universe I’d never heard of. My last attempts to make things look nice were with jQuery and Bootstrap… and now I feel old.

I heard of shadcn/ui from their MCP server announcement. Realizing what a blessing it was (especially for people like myself), I knew I had to build something.

So here it is: whatever YouTube Studio didn’t give me and I had to crunch numbers for myself. The growth dashboard shows all videos aligned by upload date on a time axis. How’s our first 48 hours performing? Are videos growing long-term? Now I have answers.

To keep things simple and avoid managing infrastructure on weekends, I went all static and client-side. All data fetching and aggregation happens in-browser, so I don’t worry much about security or GDPR. This means not all things are possible (hello Reporting API), but we work with what we have.

This is still in private beta for friends, but if you’re interested—hit me up on Twitter @prog893, DMs open.

One thing that helped: using TypeScript everywhere. With LSP integration in Claude Code and pre-commit type checks and linters, bugs get caught before commit. Fewer “write broken code, fix it later” cycles. And since everything—CLI tool, analytics dashboard—is in TypeScript, models can cross-reference and learn from patterns across projects. LLMs being genuinely good at writing TypeScript contributed to development speed too.

A couple of books

I fed visual references to a VLM which generated custom TeX style files, leveraging open-source packages and existing .sty files as context. The model could even debug TeX issues. I had a 140-page book in 3 weeks. Based on 5 years of notes, of course. Still impressive, and hopefully life-changing. Coming soon.

So what happens next?

My longer-term predictions:

  • It will become much harder to get funded for B2B SaaS. The “if you need it, build it yourself” age is coming, and before that, markets will be oversaturated with variants of the same thing.
  • As with AI-generated art and music, taste will remain a relevant “human” skill. Humans will stay bottlenecks—but that’s not a bad thing.
  • Solid basic knowledge will be more important than ever. Not just for detecting hallucinations, but for using inference efficiently by steering away from known bad decisions.

My place in this AI world

On a personal level, I’ll continue limiting AI in my creative work. I use it for file management, transcripts, and classical AI tasks like masking and upscaling. We tried web research and fact-checking automation, but hallucinations caused more burns than gains, so I limited usage there.

This isn’t to say “all AI art has no soul” or that there aren’t legitimate force-multiplying tools for artists. Rather: AI wasn’t the silver bullet that every model release feels like (especially with social media hype). We haven’t found tools that fit our budget—or justify paying for instead of humans.

Am I a worse engineer for delegating coding to AI? Delegation is a virtue. I’m creating what I couldn’t before, and I haven’t lost earlier skills. If anything, I feel like a 0.8x engineer became 1x in pure skill, and with AI assistance, 1x becomes 2x. I can now talk about how VITE+ is amazing, or how I eliminated backend needs using pagefind for search. These 3 months have been great exercise—both rapidly building and maintaining things, not abandoning them.

Future looks bright. AI remains a force multiplier for me, maybe even more so. Throwing tasks at AI from laziness is different from using it safely while understanding limitations. Being responsible for what you create. Reminding myself of this is one reason I wrote this.

Unless, of course, something big happens again—which history shows it will—and our paradigm shifts yet again, and the singularity arrives. We’ll have different problems then. But as we wait for whatever future comes, here I stand: a 1x engineer wielding AI’s power, looking at my GitHub grass field, breathing in the fresh spring air. Standing there, observing how much I think I’ve achieved. Like the 10x engineers I once aimed to become.

キヤノンカメラ歴1.5年を振り返る:レンズキットからフルサイズと大三元まで

お久しぶりです。令和初の投稿です。ブログ始めました宣言をして満足し、ここを放置していました、プログラミングヤクザです。仕事の話をしようにも、最近はブログにして面白いかつ外に発信しても怒られないネタがないので、趣味の話をさせてください。

この一年半年間の振り返りにお付き合いください。機材の選定方法や独学でカメラを学んでいる方法についても紹介しています。※機材の画像をクリックするとAmazonに飛びます。

EOS 80D レンズキット EF-S18-135mm F3.5-5.6 IS USM

中学校のころから、親戚、友達が撮った写真をいじるのが好きでした。Photoshop CS4から触っていて、経験年数だけでいうと本業より長いです。UIは親の顔よりも見た。他人の写真ばかり見ていくと、俺ならもっと良い写真が撮れるという、謎の自信が溢れ出てきます。そして一眼レフに手を出してしまいました。2017年10月、初めてのカメラである80Dを購入しました。

カメラの選定ですが、とりあえず所持金で買える最高のものを買おうという方針で80Dに決めました。カードなどアクセサリ込みで15万円ほど。当時発売されたばかりの9000Dとで迷いましたが、「桁数が少ないDの方がいいよねっ」という謎の知識を駆使して80Dにしました。(補足:キヤノンのカメラの中では最高級とされているものは現在1D X Mark II、その次は5Dシリーズ、などのように数字が小さい方がスギョイ(語弊)というアレです)

買って1週間後に撮影したものがこちら。

IMG_0667
Canon EOS 80D | EF-S18-135mm f/3.5-5.6 IS USM @ 135mm | 1/250sec at f/5.6 ISO 4000

ハイライトと赤色が飛んでいてフォーカスが若干ずれている初心者写真をLightroomで誤魔化すスタイル。現像とリタッチの経験があったので、カメラを買ってすぐRAWに切り替えました。「F値?なにそれ。シャッタースピードとISOでぶん殴ればなんとかなるだろ?」と思いつつ、写真を撮り始めたのです。まだ若かったなその頃は。ISO 4000って、本当にどうしてたんだ?

オートで撮るのはかっこ悪いと感じ、教材を探し始めました。DigitalRev TVの動画でカメラ撮影と機材の知識を身につけつつ、写真撮りまくるという学習プロセスを回し始めました。APS-Cとフルの違い、F値・ISO・シャッタの関係性の基本、三分割法などの構図の基本、固定最大絞り(固定最小F値)とそうでないレンズの違いについて学びました。学習に半年費やしたら、こんな写真が撮れるようになりました。まぁまぁマシになりましたね。

IMG_3850
Canon EOS 80D | EF-S18-135mm f/3.5-5.6 IS USM @ 18mm | 1/160sec at f/8.0 ISO 100

80Dのキットレンズが18-135mm F3.5-5.6だったので、これは18mmでは最大絞り(最低F値)がF3.5、135mmではF5.6だったので、フルマニュアルでも焦点距離を変えると設定が勝手に変わり、露光が変わっててイライラしていました。F4のズームレンズを買おう、ってなるのは自然な流れなのですが、私は「キヤノン大三元」の存在を知ってしまったのです。キヤノンの大三元レンズはフルフレーム(EF)、赤い輪がついてる最高級Lシリーズ、最大絞りF2.8固定の広角(16-35mm)、標準(24-70mm)、望遠(70-200mm)レンジの3本のズームレンズです。この3本のズームさえあれば、大抵の撮影に対応できるのです。完全に余談ですが、英語では大三元レンズは「The Hoy Trinity of Lenses」と言います。日本語では麻雀由来であるのに対し、英語は聖書由来ですね。

また、暗いところで撮影することがちょいちょいあったので、照明を考えるべきところをISOでぶんなぐろうとしていました。フルフレーム、上位グレードのお高いカメラを買えば高いISOでのノイズが少なくなるという知識を吹き込まれていました。フルフレーム一眼と大三元を揃えるという目標ができてしまったのです。半分論理で半分お気持ち…だって大三元あったらかっこいいでしょ!そして最高級のレンズを揃えることで、自分の技術が足りないのではなく機材が悪いという言い訳ができなくなるわけですよ。

EF24-70mm F2.8L II USM

 

ボディをフルフレームにいきなり買い換えられるとさすがに痛いので、まずはEFの標準ズームレンズを手に入れました。70-200mm F2.8L系が伝説のポトレ神レンズであることをまだ知らなかったことと、広角で撮影することが少なかったので、大三元を標準レンズから揃えていくことにしました。とりあえずつけてみて適当なものを撮ってみると…

IMG_6046
Canon EOS 80D | EF24-70mm f/2.8L II USM @ 70mm | 1/500sec at f/2.8 ISO 160

すげぇ…F2.8すげぇ…このボケ味に一目惚れしました。一眼欲しい人あるあるですが、このボケによる柔らかい表現、被写体と背景の分離を求めている人が多いでしょう。この効果の度合いが被写界深度によって決まり、被写界深度は焦点距離と絞りによって決まります。前のレンズで135mm F5.6の設定でもぼかすことができましたが、焦点距離を変えると今度背景が変わってしまいます(焦点距離を変えると背景の圧縮効果が変わるため)。この背景を保ちつつこのボケを出す、という要求が出始めると札束で殴って明るいレンズ(= 絞りが大きくF値が小さい)を買うしかないのですね。

ズーム全域でF2.8が出せるレンズを手に入れ、学習を進めていくとF値を意識するようになったので、この時期から撮影モードがもっぱら絞り優先(Av)になりました。インターネッツで見つけた良さそうな写真の見た目をパクってみようという学習方法に切り替えはじめました。例えば、次の写真では、道を真ん中にして奥行きを圧縮し、前後の広域にピントが合うようにする、というよくみるストリートショットっぽいものを自分で撮ってみました。

IMG_6533
Canon EOS 80D | EF24-70mm f/2.8L II USM @ 70mm | 1/125 at f/10 ISO 500

EOS 5D Mark IV ボディ

 

2018年10月。会社に出勤するつもりが、いつの間にかカメラのキタムラのレジで一括払いキメてました

5Dシリーズは高校の頃から知ってました。5D Mark IIは、動画撮影に改革をもたらしたカメラとして憧れていました。気づいたらいつの間にか5D Mark IV(通称5D4)が出ていたので、これにしました。5D RやRsほどの画質が必要なかったので、無印にしました。理想はもちろん1DX Mark II(通称1DX2)ですが…30万と50万は大きな違いです。当時は動画撮影や高速連写を求めていなかったので、5D4で十分だという結論に至りました。

0F2A0241
Canon EOS 5D Mark IV | EF24-70mm f/2.8L II USM @ 70mm | 1/1000 at f/3.2 ISO 100

APS-C機だった80Dからフルサイズに切り替えて、ダイナミックレンジが広くなり、ボケがさらに綺麗になりました。ISO 3200ぐらいまでノイズが気になることがなく、暗くてフラッシュが使えない場所では勇気出してISO上げられます。

ボタンのカスタマイズがかなり自由にできます。AE-ONボタンをONE SHOT AF(真ん中の1点のみ)、AF-Lock (*みたいなアレ)ボタンをAI SERVO AF(真ん中のグループ)に設定しました。シャッターの半押しを測光のみにすることで、AFポイントと測光ポイントを分離させることができ、素早くONE SHOTとAI SERVO間の切り替えができます。詳細は例えばこの記事を参照

EF70-200mm F2.8L IS III USM

 


2018年11月。会社に出勤するつもりが、いつの間にかカメラのキタムラのレジで一括払いキメてました…通勤路を変えないと破産しますわ…

神レンズ。メルカリで中古品を一年近く見ていましたは、いつの間にか3型が出て、新品で買ってしまいました。早速、作例:

0F2A1225
Canon EOS 5D Mark IV | EF70-200mm f/2.8L IS III USM @ 125mm | 1/250 at f/2.8 ISO 100

そして私がポートレートを撮るようになったのであります。

0F2A1049
Canon EOS 5D Mark IV | EF70-200mm f/2.8L IS III USM @ 200mm | 1/2500 at f/2.8 ISO 100

110-200mmレンジでヘッドショットの歪みがほぼなく、自然に見えます。とても綺麗に写ります。200mm/F2.8で離れた背景のボケ具合が最高です。

このあたりから教材はPeter McKinnon氏の動画とCreativeLiveのコースになりました。カメラの基礎から企画、ポージング、ディレクション、などなどについてインプットしまくってます。Peter McKinnon氏の動画や作品にめちゃくちゃ大きく影響されて、動画撮影にハマってしまいました。RONIN Sをいつの間にかポチってしまい気がついたら届いていたなどの事件が起きまくりです…

スピードライト 600EX II-RT

 


光は大事。スタジオライトやソフトバックスなどのアクセサリを揃えるのは難しいし、そもそも照明初心者として何を買えばいいか当時わかりませんでした。一旦スピードライトのみを買って、トランスミッタ、スタンドなどのアクセサリを徐々に買っていこうという作戦でした。結局、このスピードライト以外の照明機材は買っていませんが、イベント撮影ではこれのみでなんとかなっています。例えば、家でちょっとしたセットを作ってテストした結果はこちらです:

050
Canon EOS 5D Mark IV | EF70-200mm f/2.8L IS III USM @ 105mm | 1/100 at f/2.8 ISO 400

天井と後ろの壁からスピードライトの光を跳ねさせています。実践で、イベント撮影で天井からのみ光を跳ねた物撮りの例はこちら:

_F2A0036
Canon EOS 5D Mark IV | EF24-70mm f/2.8L II USM @ 47mm | 1/60 at f/2.8 ISO 400

狭くて暗い、バーやクラブみたいな場所では、24-70mm 2.8とこのスピードライトでなんとかなります。そもそも、こういった場所ではライトを設置するのも難しいので、撮影スタイルが変わることはなさそうです。

EF16-35mm F2.8L III USM

 


これを買うはずだったのに、なぜか85mmを買ってしまいました。大三元最後の一本なのに何をしてんだ…

EF85mm F1.2L II USM

 


そしてなぜこれを買ったのかはっきりしていません。人物撮影に向けての準備で一旦買いました。F1.2Lにする必要性は全くなかったんです。フォーカスがめちゃくちゃ遅いし。しかし、1.2はロマンです。持つだけで価値が(個人的には)あります。B-Roll的な動画を撮ることに今後活用しつつ、ポートレートで使っていく予定です。まだ使えてないので、テストショットでお許しください:

_F2A2351.jpg

ご覧の通り、ボケがめちゃくちゃ柔らかくて綺麗です。活用方法が見つかったらまたここで報告します。

まとめと今後の話

沼は深くて気持ちい良い!本業とできるだけ被らない趣味を求めた結果、このようにやばい沼にどハマりしました。でも、良い出会いが社内外に多くあって、後悔はないです。土日は大抵、撮影で出かけていますし楽しいです。1年と半年で機材をゼロから揃えて、ほぼゼロから学んできました。次のステップに進むべく、学習としては、ポージングとディレクションを中心にインプットし、構図力と想像力を高める方法を探します。1年後またどこまで成長できるか楽しみです。

5D Mark IVの動画性能は、1080pで最大60fpsで4Kは30fps(ただしMJPEGのみ)なので、スロー1080pと4Kで大きく負けています。4Kで1.7倍のクロップも悲しいです。最近は動画を撮影することが増えてきて、今は5D Mark IVで対応できていますいが、ひょっとしたらそのうち1DX Mark IIに手を出すかもしれません。あと、動画撮影でシネマティックな広角カットを入れたくなってきたので16-35をそろそろ買わないといけませんね。

大三元を揃えて、50mm 1.2Lを追加するかもしれないという予定でしたが、照明を駆使していい感じのスタジオっぽいポートレートや宣材写真が撮れるようになるために、先に照明を揃えていきます。ブランド選定の結果、Profotoにしました(ここツッコミどころです)。購入計画と機材詳細についてもまたまとめます。

ということで、今回の記事いかがでしたでしょうか。ツイッター等で感想を聞かせてください。最終的に出来上がったキット(残りの機材やアクセサリ含め)をこちらでもまとめていますのでよければご覧ください: https://kit.com/prog893/canon-full-size-photo-video-base-kit

個人ブログ始めました

はじめまして。prog893であります。某社で「SRE」と「インフラ」と「SA」を足して3で割った感じの仕事をしています。

ずっと個人ブログ作る作る詐欺をしていたが、やっと作りました。プライベートでまでサーバの面倒を見たくないので、 とりあえず、full-managedなWordPress.comの一番安いプランで作行きます。¥149でGoDaddyで買った.comドメインと$48で買ったスタンダードプランにしました。はてブのボタンが置けれないとか、プラグインが好きに配置できないなどといった制約がありますが、とりあえず、シンプルでスモールスタートでいきます。

そもそもどういうのを書いてきたかと言いますと、まずはちょっと話題になったこれ:「DBが真っ白になっても55分で完全復旧ができるまでの道」。実は人生で初めて書いた技術ブログだったりします。技術領域でいうと、コンテナ周りには比較的自信があって、DBについて記事書いたら叩かれる予感しかなかったのですが、なんとかなったみたいです。ちょっとした裏話をすると、問い合わせや検証などに3ヶ月近くかかり、ブログ執筆には2ヶ月かかった記憶です。半年に一度こんな記事が書けたらすごくいいですね。

2件目は、全然話題にならなかったこれ:「EC2 Auto-ScalingでECS組んでますか?エラーレート高いですか?救ってあげてもいいですか?」。話題にはなってないが、とても基本的なことを述べているつもりで、職場でECSの構築をしているとき、記事で紹介している通りにやってます。スケールイン保護的なアレもそのまま使ってます。地道な作業とデバッグについてひたすら解説しているだけなので、読者にとって読んでいて楽しいものではない自覚はあります。

とまぁ、世の中に放り出している技術的な記事は、この2件しかないのです。ちょっとした備忘録っぽい記事をローカルか社内限定公開してきたが、大きなデメリットが二つあります。1つ目は、自分自身がすでに検証し、記事にもまとめていることを忘れることです。グ自然にググると当然ながら出てこない。2つ目は、記事を書いて記憶が残っていても、どこに置いたかを忘れるのです。ローカルとかEvernoteとかesa.io的なものなどと、場所が散らばったりするから、検索がめんどい。

一般公開しても良さそうなものは、ここに置くようにしていくつもりでいます。公開してもいいけど個人ブログからは出せない技術的な記事に関しては、引き続きDevelopers Blogなどに投稿していきます。技術的にはペーペーなので、最近始めたカメラについても書くと思うし、謎の近況投稿もあると思います。

平成最後の秋の今日、11月5日が個人ブログ開設記念です。

ブロガーライフ、はじまる。