Automate Codex CLI workflows with oh-my-codex

⭐ Just starred: materialofair/oh-my-codex The 'oh-my-codex' project provides workflows for the Codex CLI, aiming to standardize and automate essential programming tasks such as coding, refactoring, testing, and code reviews, thereby enhancing efficiency in software development. https://lnkd.in/gEpDea5Y

## The best code I've ever read was... boring --- True story. I was reviewing this codebase from a guy who's been coding for 20+ years. Expected to see some wizard-level stuff. Clever one-liners. Fancy patterns. Nope. It was almost... boring? Clean. Simple. Readable. Zero ego. And I realized something: **Good code doesn't impress in a code review.** **Good code saves your butt at 3 AM when production is down.** Here's what I've learned after 25 years: **Naming is everything** ❌ `processData()` - what does this even mean? ✅ `calculateMonthlyRevenue()` - oh, I get it **Functions should do ONE thing** If your function has "and" in the name, it's doing too much. ❌ `validateAndSaveUser()` Just split it: `validateUser()` + `saveUser()` **Comments should explain WHY, not WHAT** ❌ `// Increment counter` (duh) ✅ `// Retry 3 times before failing - handles transient network errors` **Delete code aggressively** Every line is a liability. The best code is the code you don't write. Anyway. Write code for the person reading it at 3 AM. That person might be future you. Be nice to them. What's your #1 rule for clean code? Curious what others do. --- #CleanCode #SoftwareEngineering #DeveloperTips

I've been using Claude Code for about three weeks now. After a long coding session, I'd close my laptop and five days later have absolutely no idea *why* I made certain decisions. The code told me what changed. Git told me when. But the reasoning, the trade-offs, the assumptions, the "I chose this over that because..." was just gone. So I built a few custom slash commands on top of Claude Code, and I use them almost every day: /simply-explain → asks Claude to document the WHY behind any decision in plain English, not jargons /code-changelog → creates a changelogExplanation.md that logs every change made during a session, with that plain-English reasoning attached to each one /session-summary → at the end of a session, reads the changelog (changelogExplanation.md) and writes a sessionSummary.md: what we built, what decisions were made, what's left The output looks like a letter to your future self. There's definitely room for improvement and to customize even more! But this one shift - treating sessions as documented decisions and not just code changes - already feels like something I'll never go back from. If you're using Claude Code, what's a workflow or slash command you've built that you couldn't imagine working without now? Attached image (recent sessionSummary.md from one of my personal project) 👇 #ClaudeCode #AIEngineering #DeveloperTools #Productivity #SoftwareEngineering

Working with coding agents keeps making the same thing obvious: code is only part of the change. I wrote my first ever blog post about why code diff is the wrong diff. https://lnkd.in/dtZ6ZBPR

The best trick for Claude Code. Start Claude code with: claude --continue --dangerously-skip-permissions What it does: • --continue picks up your last conversation, so you don't lose context between sessions • --dangerously-skip-permissions removes the confirmation prompts — Claude just does the thing The result is a fully autonomous coding loop. No "are you sure?" dialogues and you are sure you will see the results while you go and get your coffee. PS: At your own risk. Obviously, you're handing over the keys. It can delete files, overwrite code, run scripts — all without asking twice. Use it on throwaway projects or inside a container you don't mind nuking. Honestly, I myself end up using it on prod as well as I know I can always recover everything from Github and I won't let Claude deploy stuff automatically.

I often people say "a sufficiently detailed specification is the code." This isn't true. Specification is an abstraction of code. Every spec is satisfied by a set of possible programs. The implementation is a single element of this set. You see this exact thing in test-driven development. In the "red-green-refactor" loop, the "red" is writing a failing test, "green" is making the code pass, and "refactor" is changing the code without breaking tests. In other words, "red" is shrinking the set of valid programs so that the current implementation is outside. "green" is moving the implementation into the set, and "refactor" is moving around inside the set. I discuss more consequences of the distinction in this week's newsletter. See the comments for a link.

spec is not code spec is usually a min requirements doc there is a set of multiple possible implementations of the spec difference? speed, robustness, cost, backward compatibility, .... can you put it in the spec? yes, but usually people skip it as spec includes more and more details it becomes closer to the code abstractions on top of abstractions...

The highlighted file in this screenshot is the most important one in my repo. It's not code. It's a claude.md file. Think of it as the onboarding doc you'd write for a contractor who starts fresh every morning with no memory of yesterday. That's Claude Code. Every session is day one. Without a CLAUDE.md, three things happen: 1. You repeat your project context every session 2. Outputs drift in voice and style 3. Claude guesses at things it should have asked about Write this once, and it travels with the project. Here's the skeleton of the one I use for https://amit.so What this repo is, who it's for, what's deployed File structure and where new content goes Git workflow. When to branch, when to commit Content and voice rules. "Voice is Amit's. Direct, specific, builder-first." Never fabricate metrics or client names. If there's no source material, stop and ask. Auto mode rules. Claude checks each tool call for risky actions and prompt injection before running The voice section alone makes every draft sound like me on the first pass instead of the fourth. The "stop and ask" rule is the real unlock, though. It turns Claude from a confident guesser into a collaborator who pauses when it's about to invent a number I never gave it. If you use Claude Code for anything you actually care about (the work project, the side project, the content channel) write a CLAUDE.md. Even a rough one. Three sections to start with: 1️⃣ What this project is and what "done" looks like 2️⃣Rules you never want broken (voice, data, permissions) 3️⃣ Context Claude would otherwise ask for every single time Ship the v1. Tune it as you go. #ClaudeCode #AIWorkflows #GTMEngineering #VibeCoding #BuildInPublic #AITools #Solopreneur

Claude Code out of the box and Claude Code on a real team are two different tools. Most people stop at the CLI. That's leaving the interesting 80% on the table. The real power sits in four configuration primitives most developers don't realize exist. You've got CLAUDE.md for persistent project memory that loads on every session and skills for packaging multi-step workflows. Claude can invoke on context or via slash command. Hooks run shell commands on harness events like PreToolUse and SessionStart, which is where format-on-save and production guardrails live. Subagents round it out with isolated Claude instances for parallel work or heavy file scans that would otherwise bloat your main context window. The honest version is that getting this set up takes about two weeks of real iteration. Week one is CLAUDE.md. Week two is your first two skills. Hooks you'll tweak forever. This is not a weekend project. But the payoff is an agent that actually knows your codebase, enforces your team's conventions, and dispatches work in parallel instead of plodding through one file at a time. That's the difference between Claude Code as a demo and Claude Code as a tool you ship production code with. Read the full setup, including working hook configs, skill structure, subagent patterns, and MCP server examples: https://lnkd.in/gJMU2E3y #ClaudeCode #AIEngineering #DeveloperProductivity #AIAgents #SoftwareEngineering

A friend ranted last week about his popular Claude Code plugin: "Every over-engineered subsystem got there the same way. Ship a feature → hit a failure → add a compensator → compensator grows helpers → new devs build on top of the helpers, never the core." He's right. I've written that code. So have you. So I built a Claude Code skill: /de-engineer. It audits one subsystem for band-aids and proposes the simpler design that should have shipped. Tested it on Nous Research's Hermes, OpenClaw, and EvoMap's Evolver. Three different teams, three different languages. Same band-aid patterns in all three. The skill is 94 lines. No test harness, no SDK, no web UI. A skill called "de-engineer" that over-engineers itself is a meme, not a tool. https://lnkd.in/gHpAUwkB