Jon Aquino's Mental Garden

Engineering beautiful software jon aquino labs | personal blog

Sunday, May 17, 2026

No API, no problem

I used Codex Computer Use plus a 1Password service account to pull my latest Real Canadian Superstore order into my grocery archive, even though Superstore doesn't offer an API.

The setup was simple:

  • Codex opened the site and navigated the login flow
  • op read piped my Superstore username and password to the clipboard
  • Codex pasted them into Chrome without printing the secrets
  • It opened my order history, grabbed the newest order, and wrote it into my markdown archive in Dropbox

What I like about this is that it works with the website as it exists today. No scraping pipeline to maintain, no unofficial API, no manual copy-paste.

Codex Computer Use also felt faster than Claude's Chrome extension in this workflow, though I haven't tried Claude Computer Use directly, so that's not a fair apples-to-apples comparison yet.

The downside is that it seems to burn a lot of tokens, probably because it's constantly reading screenshots of the page.

It's a good example of where computer use is more practical than waiting for a proper integration that may never come.

Friday, May 15, 2026

Making AI comic adaptations of famous books

I've been turning famous books into AI-generated comic books with ChatGPT, which is great at this.

The workflow is six prompts:

  1. Plan a 30 page comic book adaptation of pride and prejudice. I want text, not an image.
  2. Create a character reference sheet for the book. Show the following characters side by side, each labeled with their name below them: [list characters from the plan]. Each character full body, neutral expression, plain warm-paper background. No panel borders. Size: 1536x1024. 
  3. Using the character reference sheet as a reference image, can you generate a batch of 10 separate images - the cover plus the first 9 pages? I want 10 images, not 1 image containing 10 pages. Size of each page: 1024x1536.
  4. Using the character reference sheet and the last few pages as style reference images, do the next batch of 10 images, page 10-19. I want 10 images, not 1 image containing 10 pages. Size of each page: 1024x1536.
  5. Using the character reference sheet and the last few pages as style reference images, do the next batch of 10 images, page 20-29. I want 10 images, not 1 image containing 10 pages. Size of each page: 1024x1536.
  6. Using the character reference sheet and the last few pages as style reference images, can you generate the final image - page 30? Size: 1024x1536.
  7. Can you put the 31 pages (not the character sheet) into a pdf?

Note the "10 separate images, not 1 image containing 10 pages" phrasing. Without it, ChatGPT can return one image with 10 panels in it.

See the rest of my AI comics here:

Monday, May 11, 2026

Exporting a Claude Code session to Codex

I found a simple way to move a Claude Code session over to Codex CLI.

In Claude Code, I ask it to export the full session context to a dated markdown file:

Export the entire context of our current session to a markdown file named context-YYYY-MM-DD.md (substitute today's actual date — run `date +%Y-%m-%d` to get it) in the current directory. Include everything needed for another AI assistant (specifically Codex CLI) to pick up exactly where we left off:

1. **Session overview**: A brief summary of what we've been working on, the goal, and current status.

2. **Project context**: 
   - Working directory and relevant repo/branch info (run `pwd`, `git branch --show-current`, `git status --short`, `git log --oneline -5`)
   - Tech stack, frameworks, and key dependencies in play
   - Any environment variables, config files, or setup steps that matter

3. **Conversation history**: A chronological digest of our exchange — my requests, your responses, decisions made, approaches tried, and approaches rejected (and why). Don't paraphrase away important detail; preserve specifics.

4. **Files touched**: List every file you've read, created, or modified this session, with a one-line note on what changed or why it was relevant. For files you created or substantially edited, include the current state or a diff summary.

5. **Commands run**: Every shell command executed, with its purpose and outcome (success/failure, key output).

6. **Open threads**: 
   - What's done
   - What's in progress (with exact next step)
   - What's blocked and on what
   - Any TODOs, FIXMEs, or questions I left unanswered

7. **Gotchas and context the next assistant needs**: Quirks of the codebase, conventions I follow, things that tripped us up, anything implicit between us that wouldn't be obvious from the code alone.

8. **Suggested next action**: The single most useful thing the next assistant should do when I resume.

Format as clean markdown with clear headings. Use code blocks for commands, file paths, and code snippets. Be thorough — token count is not a concern here; continuity is. When done, print the file path and a short confirmation.

Then in Codex CLI, I start with the handoff file:

Read context-*.md in full before doing anything else. That's the handoff from my previous session — treat it as the ground truth for where we are and what to do next.

It works well because the handoff file is explicit about both code state and conversation state. The next assistant does not have to infer what happened from git diffs alone.

This is becoming one of my standard patterns for moving work between AI coding tools.

Sunday, May 10, 2026

Using codex to investigate PagerDuty alerts

 Codex CLI is so smart (gpt 5.5 medium, maybe better than Claude Code). I just told it to "get my PagerDuty incidents and find the root cause", and it:


- read the PagerDuty skill in our company skills repo

- used it to list my team's active incidents

- checked the missing S3 success files

- traced the alerts back through the Airflow DAGs

- queried live Airflow task state in prod

- checked S3 timestamps for upstream sludge success files

- used Trino to verify the alert

- concluded that the main issue was late sludge log completion delaying downstream metrics, while the alert was a real low-volume threshold miss, not missing data


Pretty amazing.