claire vo

Bulk edit crops, lighting, and red-eye in Lightroom with Codex computer use

I had 131 event photos to clean up. I opened them in Lightroom and asked Codex to straighten the shots, improve the crops, and fix red-eye. It used computer use, looking at the screen and clicking through the desktop app.

1. Adjust the lighting across the batch so the photos have a consistent starting point.
2. Review each photo individually for crooked horizons, awkward crops, and red-eye. Those decisions need to be made photo by photo.
3. Check the whole set after the edits, keeping the changes reversible in Lightroom.

It reviewed all 131. I could hand off the repetitive editing while keeping the photos in the app where I’d normally review them.

lightroom-photo-lab.pngclose esc

Original imagedownload .png ↓

# Photo polish

Use computer use to work in the Lightroom desktop app I have open. Review the selected event photos, keeping edits reversible.

## Establish the lighting

Inspect a few representative photos first. Adjust exposure, highlights, shadows, and white balance to suit the batch. Check automatic corrections before accepting them—direct-flash portraits can become too bright.

If the photos share similar lighting, copy only the appropriate light/color adjustments across them. Do not copy crop settings or localized eye corrections. Revisit photos whose lighting differs from the rest.

## Check each photo

Move through the selection one photo at a time. Straighten against visible reference lines and inspect the result. Crop awkward edges or excess headroom without cutting people out. Zoom in enough to check red-eye, apply corrections where needed, and inspect the eyes afterward.

Keep track of which photos have been reviewed so none are skipped. Do not claim every photo was individually adjusted if only shared settings were applied.

## Finish

Review the edits and check Lightroom's save/sync status. Report what changed, the number reviewed, and anything still unfinished. Do not export or share unless I ask.

Free up disk space by clearing Git worktree caches with Codex

My laptop was almost out of space. Git worktrees let me work on several branches at once, but each checkout can accumulate its own dependencies and build files. One Next.js cache alone was taking up 18.9 GiB.

1. I asked Codex to use the terminal to find the biggest folders and explain what they contained.
2. It checked Git status and running processes to separate my code and active work from files the tools could recreate.
3. I picked what to remove, and Codex cleared those cache and dependency folders.

That recovered 24.7 GiB. The worktrees and uncommitted changes stayed; dependencies in the cleaned folders would need reinstalling. Having an agent investigate the folders first saved me from guessing what was safe to delete.

git-worktrees-bitmap.pngclose esc

Original imagedownload .png ↓

# Make room, keep the work

Help me recover disk space in the repositories and worktrees I select.

## 01. Look before touching

Measure disk usage. Identify large generated caches and reinstallable dependencies. Check Git status, ignored files, and active processes. Keep source files, local work, credentials, and databases out of the cleanup list.

## 02. Make the plan concrete

Show the exact paths, their sizes, what each contains, and whether a running process uses them. Separate cache cleanup from deleting whole worktrees. Explain what will need reinstalling or rebuilding.

Ask me to approve the exact cleanup targets and any processes you need to stop.

## 03. Clean only the approved targets

Use the narrowest appropriate operation. Never expand a target to its parent directory or delete worktrees just because their caches are large.

## 04. Verify the result

Measure the space recovered. Confirm source files and uncommitted changes are unchanged. Report any stopped processes and what I need to reinstall before running a project again.

Schedule podcast and blog posts in Sanity with Codex browser use

A How I AI release includes the episode post and companion posts explaining the workflows from the conversation. Getting them all ready means finding the related drafts, checking their URLs, and scheduling each one. It’s a lot of clicking through the same CMS screens.

I gave Codex the episode and publish date, with Sanity already open in Chrome. Using computer use in that browser session, it found the three companion posts, cleaned up the URLs, and scheduled all four. I could delegate the release as one task instead of walking through each post myself.

sanity-publishing-desk.pngclose esc

Original imagedownload .png ↓

# Schedule a podcast release

Use browser or computer use in the CMS session I already have open. Help me prepare and schedule the episode and related posts I select.

I will provide the episode, publish date, time, and time zone. Find its companion posts and handle the repetitive editing and scheduling work across the set.

## 01. Identify the release

Confirm the exact documents, publication date, time, and time zone. Check the current draft and schedule status of every document. Do not guess which similarly named post belongs in the release.

## 02. Review the content

Check titles, slugs, internal links, summaries, images, and required fields. Flag anything missing or inconsistent. Distinguish a saved draft from a scheduled snapshot.

## 03. Check the version that will publish

Make sure the scheduled version contains the intended draft changes. If the CMS keeps an earlier snapshot, show me what must be replaced and preserve the latest draft.

Ask for approval of the exact content and schedule before creating or replacing publication schedules, unless I have already approved them in this session.

## 04. Read it back

After the authorized scheduling action, verify each document's saved slug, scheduled version, publication date, and time zone. Report scheduled and published states separately. Note any links that will only work after publication.

Build an event screen from Figma and a slide PDF with Codex

For How I Happy Hour, I wanted people to share an AI workflow from their phone and see it appear on a screen in the room. I gave Codex our Figma branding and a brief, then opened the app it built and directed changes by commenting on the page in the browser.

It handled the phone form, the rotating board of submissions, and an image people could share afterward. When I added a PDF of event slides, Codex converted the pages and mixed them into the same screen rotation. I could work from the brand files and slides we already had, then give feedback on what guests would actually see.

event-screen-pixel.pngclose esc

Original imagedownload .png ↓

# Turn an event PDF into a rotating screen

Add a full-screen event page that alternates the supplied PDF slides with the app’s live board. Inspect the PDF first, skip genuinely blank pages, and preserve each slide’s aspect ratio and complete content. Convert the pages into appropriately sized browser assets without requiring me to export them one at a time.

Make the screen loop automatically. Choose sensible reading time for each type of slide, include pause and next/previous controls, and let the controls fade while the screen is playing. Keep the live board fresh between slide appearances.

Preview at the display’s resolution. Verify every slide loads, nothing is cropped, the live board appears, and the playlist returns to the beginning. Show me the complete preview. Deploy when requested, then verify the deployed screen and tell me whether already-open screen tabs need a refresh.

Make an editable SVG character animation with QuiverAI, CoAnimator, and Codex

I saw this animation by @rege_dev on X and asked Codex to teach me how to make something like it. I wanted to be able to change the character’s expressions and timing after it was made.

QuiverAI generated the character as an SVG, an image made of editable shapes. Codex brought it into CoAnimator, then used the animation timeline to add blinks, head tilts, changing expressions, and sound. Keeping the character’s parts separate meant it could move the eyes or tilt the head without regenerating the drawing.

The loop below is the actual result. Along with the eight-second video, I got the source illustration, editable project, and instructions for making another one.

// Adapted timing example, not the original character project.
const duration = 8;

export function poseAt(seconds) {
  const t = ((seconds % duration) + duration) % duration;
  const phase = t / duration;
  return {
    headTilt: 8 * Math.sin(phase * Math.PI * 2),
    eyeScaleY: 1 - Math.exp(-Math.pow((t - 3.2) / 0.09, 2)),
  };
}

// Preview, scrubber, and exporter all call the same function.
// Apply poseAt(seconds) to the independently editable SVG parts.

Turn podcast photos into consistent portrait assets with Codex and Flora

Our How I AI thumbnail designer needs good cutouts to work with. I had photos from a recording and an existing style in Flora, the image-generation board we use: a black background with purple light around the subject.

After I imported the photos, I had Codex operate Flora in Chrome using computer use. It set up an image edit for each pose, matched the lighting and background, and exported full-resolution PNGs with names our designer could understand. Later I came back with a two-person photo and had it apply the same treatment.

That took care of preparing a consistent set of source images. Our designer could start arranging the thumbnail instead of spending that time cleaning up each photo.

flora-portraits-bitmap.pngclose esc

Original imagedownload .png ↓

# Prepare portrait sources for a thumbnail designer

Use computer use in the open Flora board in Chrome. Inspect the existing portrait examples to understand the studio treatment before editing my supplied recording photos.

Create one image-edit node per pose. Preserve the person, expression, head angle, hand pose, and natural anatomy. Match the established background, clothing, lighting, and crop. Keep the whole head and relevant hands inside the frame with a little margin. Do not add text, logos, or thumbnail graphics.

Generate high-resolution 16:9 PNGs. Inspect each result for facial and hand errors. Export the full-resolution originals, name the files by pose, and package them with a short file list for the designer. Leave clearly named nodes in Flora so we can reuse the treatment for another photo.

Prototype a hand-tracking Mac app with Codex and Apple Vision

I wanted to try controlling my Mac with hand gestures through the camera. I described the idea to Codex, and it built a native app using SwiftUI for the interface and Apple Vision to recognize hand positions. It included a practice area so I could test gestures before using them to control the computer.

Then I tried it. Nothing moved. I told Codex what I was seeing, and it used computer use to inspect the running app and macOS permissions, then adjusted the controls. By the end, the prototype was recognizing my pointing gesture.

The useful part was that I could try the interaction and have the same agent look at the app with me. That got the idea far enough along to test what a hand-controlled interface could feel like.

hand-tracking-bitmap.pngclose esc

Original imagedownload .png ↓

Build an AI lead-routing workflow in Attio with Codex browser use

New CXO.dev leads can be interested in a course, training for a team, or consulting. Before anyone follows up, we have to read the context and decide who should take it. I had Codex use Chrome to build a draft workflow in Attio, where we keep those leads.

1. Gather the deal, company, contacts, and notes so the decision uses the context already in Attio.
2. Have an AI step choose an owner using the rules I provided, explain its choice, and flag unclear cases for review.
3. Assign the deal and send a short Slack handoff with the context and a link back to Attio.

I described how I wanted leads handled. Codex set up the fields, branches, and message variables in the browser. The goal is for someone to get a lead they can act on without first having to dig through the CRM.

attio-routing-bitmap.pngclose esc

Original imagedownload .png ↓

# Draft a lead-routing workflow in Attio

Use computer use in Chrome to configure an unpublished Attio workflow for the lead handoff I describe.

First inspect the existing workflow and show how its steps connect. Use my routing rules and the exact owners I provide; do not invent either.

Configure an agent to read the triggering Deal and its linked People, Company, and Notes. Return one owner, a short reason, a review-needed flag, and one readable lead summary. Use only information supported by the linked context. Mark missing or conflicting information for review.

Order the steps as follows:
1. Enrich the lead context and choose an owner.
2. Update the Deal owner through the appropriate branch.
3. Prepare the Slack handoff with the owner, reason, review flag, concise lead summary, and a direct Attio link.

Check the saved owner fields, message variables, and workflow diagnostics. Keep the workflow unpublished. Report exactly what is configured and what still needs a live test. Do not send test messages or contact leads.

Show what your AI agents are doing on a Divoom MiniToo

I wanted to see what my agents were doing without opening another task. The Divoom MiniToo is a little pixel display that can sit on my desk, so I asked Codex to give my agents a way to send updates to it.

I started with bugzmanov’s MiniToo toolkit and alvinunreal’s macOS project. Codex used that work to build a local command-line tool and plugin. An agent could send a short progress message, live typing, or an animation over Bluetooth. A temporary update could disappear and bring back the drawing that was there before.

I got the updates showing on the screen. Now progress could show up beside my computer while I stayed in whatever I was working on.

pixel-agent-companion.pngclose esc

Original imagedownload .png ↓

Organize Figma colors into reusable light and dark themes with Codex

A palette tells you which colors you have. It doesn’t tell you which one to use for a button, a background, or an error message. I gave Codex a copy of our Figma palette and asked it to organize the colors around those jobs.

These are called semantic tokens: a name describes what a color does, so the same background can use a light color in light mode and a dark one in dark mode. Through the Figma connector, Codex linked those names to our existing brand colors, set up both modes, and rebuilt the swatch sheet.

It created 99 tokens and connected the swatches to them. I could review how the colors should be used instead of manually creating and binding every variable.

figma-color-tokens-bitmap.pngclose esc

Original imagedownload .png ↓

Work in this copied Figma palette. Inspect its existing primitive and semantic color variables before making changes.

Organize colors by their jobs: backgrounds, text, borders and focus, actions, feedback, indicators, data visualization, and workflow states. Include a five-step good-to-bad scale and matching subtle backgrounds.

Reuse the existing brand colors through variable aliases. Support light and dark modes, and reuse existing semantic variables where they already fit.

Update the copied swatch sheet so the visible examples are bound to their semantic variables. Read back the result and verify the number of tokens, light/dark aliases, unbound swatches, remaining primitive labels, and clipped or overflowing content.

Report what changed and any unresolved naming or accessibility questions.

Build and test a Codex skill that checks a codebase before you start coding

I wanted to reuse the checks we do when starting work on a codebase: can an agent figure out how to install it, run it, and test a change? A Codex skill is saved instructions, sometimes with helper scripts, that an agent can use again. This was one of a set I made for repeat engineering work.

1. I asked Codex to turn those checks into a skill, including scripts to inspect the project and tests using sample repositories.
2. I had a second agent try the skill on our own site. It found a test command that existed but wasn’t running in the automated checks.
3. That trial also exposed a gap in the skill: it missed instructions in the parent repository. Codex fixed the scanner and added a test for that case.

The next time I start work on a project, I can ask Codex to run that skill. The instructions and checks are already there, including what we learned from trying it on our own code.

tested-agent-skills-pixel.pngclose esc

Original imagedownload .png ↓

Open-source an internal code-review agent with Codex

We had an agent at ChatPRD that reviews proposed code changes on GitHub. I wanted other teams to be able to use it, but our version assumed our codebase, our risks, and our team. I asked Codex to make it something another team could set up for themselves.

Using the terminal and GitHub CLI, it pulled out the company-specific assumptions, made the review rules configurable, and wrote a setup guide. We also included a skill that helps adapt the reviewer to a different team’s technology and priorities. Codex tested that customization against a fictional project with a different stack.

The public repo includes the reviewer and the customization instructions. That meant I could share a tool we already used with a way for people to make it useful in their own codebase.

pr-review-pixel.pngclose esc

Original imagedownload .png ↓