This post dives into my personal productivity workflow, the one I use for creating all sorts of content, from blog posts and Twitter updates to YouTube videos. It's all about building a system tailored to my needs, using tools like UV scripts, Just files, and leveraging the power of 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. However, I’ll write up explanations and details for those that really just want to read about it.
Introduction: My Personalized 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 a one-size-fits-all solution, and I don't expect everyone to adopt it wholesale. In fact, you SHOULDN'T. You should build your own mini-productivity tool.
But hopefully, sharing my approach will spark some ideas for creating your own for what fits you. My focus is on speed, flexibility, and making things work for me.
The core of my system revolves around a few key components:
UV Scripts: Small, self-contained Python scripts managed by UV.
Just Files: A command runner that provides a central point of access to all my scripts.
AI Assistance: Leveraging AI to generate and maintain the scripts.
Thanks for reading Elite AI Assisted Coding! Subscribe for free to receive new posts.
The Just File [00:54]
But basically I have a just file that has all my commands.
Think of the Just file as my entry point for everything for me and my agents. It's a single place where I can define and access all the commands I need to run my various scripts, or point an agent to 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 to run, or think about whether I’m in the right environment, or the right github api command. It’s all there for me and the agent, and it displays things exactly as I want them to.
For example, the twitter_drafts.py script is run with `just twitter-draft “content”`. Content can be a URL (maybe to tweak about my blog post I just wrote), or it can be a voice transcription of an idea I had. The script fetches content, generates some starting point drafts, and then drops it into a directory so I can circle back to it whenever I have time. It also prints out some follow-up instructions for an LLM agent around naming it, so I get nice names automatically when an agent runs it.
It's about streamlining the process and avoiding remembering complex commands [05:52].
Why are you rolling your own github issue reader?
People often ask why I create my own things vs use some tool. For example, why my own script for reading GitHub issues and not the official GitHub MCP? The answer is customization, and how AI has shifted the cost of creating them
Customization: It is often much faster and easier to customize and tweak something you created for yourself. Partly because you may know it better, but partially because it’s just going to be a lot simpler. It doesn’t need to handle every case, only the few that I care about. That means it’s super simple and easy to change.
Creation cost: It used to be that to create a script for something like that, you’d need to figure out what the library is, install it, look at the docs, fiddle with it as you figure out the library, then have your script. It wouldn’t take long, but enough time that you might just want to use the tool. Over time, you get faster as you memorize the parts of the API you use a lot. With AI, I created the script in less than 10 seconds. It would have taken much longer to figure out how to download, install, and configure a pre-built solution.
I use my system for various content formats, from quick Twitter updates to more involved YouTube videos and blog posts. For example, the Twitter draft script [01:14] creates a starting point with three versions of a tweet and some things to think about. This helps kickstart the creative process whenever I have an idea.
The `just yt-pipeline` command is more complicated and runs a series of scripts for me:
Download the YT video
Create chapter timestamps
Create transcription with periodic timestamps
Take a screenshot every 3 seconds and store in a folder
Make a content plan (kind of an intermediate thinking step)
Draft a blog post with the screenshots embedded in the post
While the generated content isn't perfect, it provides a fantastic starting point that saves me a ton of time [07:44]
But I have a tool for that too! One key tool is a custom markdown editor [03:02]. Again, I don’t need to remember any specific commands, I just use the justfile and it runs with `just app`. One of the really useful things is image selection, where I can use the arrow keys to quickly cycle through screenshots and find the best one to use in my content [03:16]. This is a feature that saves me a lot of time but 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]. This means that each script has its own dependencies and environment managed by UV. This isolation is crucial for flexibility and maintainability. If I want to change how a specific script works, I can simply tweak that 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 just make a python library?
Yes. I absolutely can, and it is what I used to do. Here’s why I do this instead now.
The cost of making and managing all these scripts used to mean it’d be a significant pain, and it was much better to make your own carefully refactored library. But that’s not true anymore; quick scripts like these literally take a few seconds to make. And they’re so isolated, it means I can go in and change one part of the process extremely quickly. I don’t have to manage local editable installs or any of that. Just files means that it is much simpler than it used to be (compared to Make files) as well.
Do I think I should make this public and recommend others use my system? No, but that’s not the goal of this. Hell, some of the prompts even have my name in them! The goal of this is a quick, easy, hackable approach to make one individual more efficient.
And everyone should have a system for that.
Key Takeaways: Building Your Own System
Personalization is key: This system is built around my specific needs and preferences [10:05].
Small, independent scripts: UV scripts provide flexibility and easy maintenance [10:10].
Centralized command center: The Just file simplifies workflow management [05:52].
AI is a powerful assistant: AI can help generate and maintain your tools [04:47].
Focus on practical functionality: Don't get bogged down in over-engineering. Make it work for you [10:17].
I hope this glimpse into my personal productivity system has been helpful! Remember, the goal is to build something that works for you, so don't be afraid to experiment and customize your own tools.
