Isaac's Personal Productivity System with UV Scripts, AI Agents, and Justfile

August 15, 2025

This post covers my personal productivity workflow for content
creation, from blog posts and Twitter updates to YouTube videos. It's a
system tailored to my needs, built with UV scripts, a Justfile, and AI.

Normally I prefer written posts over videos, but in this case I
highly recommend you watch the video. Workflows should be seen,
not read about. I'll still write up explanations for those who prefer
text.

Introduction: My Productivity Approach [00:00]

Hi, I'm Isaac. I'm here to show you my personal workflow that I use
for all kinds of productivity tasks.

This isn't one-size-fits-all. Build your own mini productivity tool.

My focus is speed, flexibility, and making things work for me.

The system has a few core components:

UV Scripts: Small Python scripts managed by UV.
Justfile: A command runner that provides one entry point for all
my scripts.
AI Assistance: AI helps generate and maintain the scripts.

The File [00:54]

But I have a file that has all my commands.

Think of the file as the entry point for me and my agents. It's one
place to define and access the commands I need, or point an agent to do
the same. Here's an example of what that looks like [01:03]:

Generate Twitter draft post from URL or thoughts

twitter-draft input:
uv run scripts/create_twitter_draft.py "{{input}}"

Launch the Air app to edit blog post markdown files

app:
uv run fastapi dev app/main.py

Read a specific issue

gh-issue repo number:
uv run scripts/github/read_issue.py {{repo}} {{number}}

With this setup, I don't need to remember the FastAPI command, the right
environment, or the GitHub API call. It's all there for me and the
agent, displayed exactly how I want it.

For example, I run twitter-draft "content". Content can be a URL or a
voice transcription. The script fetches the content, generates draft
options, and drops them into a directory for later. It also prints
follow-up instructions for an LLM agent to name it automatically.

It simplifies the process and avoids complex commands [05:52].

Why are you rolling your own GitHub issue reader?

Why build a script for reading GitHub issues instead of using the official GitHub MCP? Customization and AI have shifted the cost of creating tools.

Customization: It's faster and easier to tweak something you built.
You know it better, and it's simpler because it only handles the cases
you care about.

Creation cost: It used to mean finding a library, installing it,
reading docs, and fiddling until it worked. It wasn't long, but long
enough to justify a tool. With AI, I created the script in under 10
seconds. It would have taken much longer to download, install, and
configure a prebuilt solution.

Content Creation Tools (Twitter, YouTube, etc.) [01:14]

I use my system for Twitter, YouTube, and blog posts. The Twitter draft
script [01:14] creates three versions of a tweet plus prompts to think
about, which helps me start quickly.

The just yt-pipeline command runs a series of scripts for me:

Download the YouTube video
Create chapter timestamps
Create a transcript with periodic timestamps
Capture a screenshot every 3 seconds
Make a content plan
Draft a blog post with embedded screenshots

The generated content isn't perfect, but it's a strong starting point
that saves me a ton of time [07:44].

But I have a tool for that too: a custom Markdown editor [03:02]. I
launch it with just app, so there's nothing to remember. It includes
image selection, so I can cycle through screenshots with arrow keys and
pick the best one for my content [03:16]. It saves time and isn't built
into any Markdown editor I know.

UV Scripts: The Building Blocks [03:55]

So how does this run? Well, every script is a small UV script.

Every script in my system is a self-contained UV script [04:01] with its
own dependencies and environment. That isolation keeps things flexible:
I can tweak one file without affecting the rest of the system [04:11].

#!/usr/bin/env python3

/// script

dependencies = ["google-generativeai", "httpx"]

///

"""
Generate a Twitter draft post from a URL or topic/thoughts.

Usage:
uv run scripts/create_twitter_draft.py "Your thoughts or URL here"

Environment:
GEMINI_API_KEY must be set
"""

Can't you make a Python library?

Yes. I absolutely can, and it's what I used to do. Here's why I do this
instead.

The cost of making and managing scripts used to push me toward a
carefully refactored library. That's not true anymore. Quick scripts
take seconds to make, and they're isolated, so I can change one part of
the process fast without touching the rest. I don't have to manage
editable installs, and a Justfile is simpler than a Makefile.

Some of the prompts even have my name in them. The goal is a quick, hackable approach that makes one person more efficient.

Everyone should build their own version.

Key Takeaways: Building Your Own System

Personalization is key: This system is built around my needs
[10:05].
Small, independent scripts: UV scripts are flexible and easy to
maintain [10:10].
Central command center: The file simplifies workflow management
[05:52].
AI is a powerful assistant: It helps generate and maintain tools
[04:47].
Focus on practical functionality: Don't over-engineer. Make it
work for you [10:17].

Build what works for you. Experiment and customize.