DEV Community: Jeff Martinez

Shipping Prism Organizer: How Scheduling My Own Cleanup Tool Found Three Bugs in One Afternoon

Jeff Martinez — Tue, 18 Aug 2026 04:14:04 +0000

Shipping Prism Organizer: How Scheduling My Own Cleanup Tool Found Three Bugs in One Afternoon

I wanted one thing this week: my Downloads folder and my Creative Cloud Files desktop to clean themselves up twice a month without me touching a keyboard. Instead I spent an afternoon debugging my own CLI tool live, in production, against my own laptop — and came out the other side with three real bug fixes and something I'm finally comfortable calling done: Prism Organizer is officially launching.

TL;DR

I'm open-sourcing Prism Organizer, a portable Python CLI + TUI for scanning, sorting, deduping, and cleaning up Windows folders — dry-run by default, nothing ever hard-deleted, everything undoable.
Trying to wire it into Windows Task Scheduler for my own twice-a-month cleanup surfaced three real bugs: a broken local Python install, an argparse naming collision that silently misrouted a whole subcommand, and a Windows schtasks quirk that only accepts one day-of-month at a time.
All three are fixed and shipped as of v1.3.2. The tool now genuinely runs itself, unattended, on the 1st and 15th of every month.
Full source, CONTRIBUTING.md, and a real SECURITY.md are up on GitHub if you want to poke at it.

Why I Built This in the First Place

Between running Syntaxure Labs, coursework at ISUFST, and SineAI Guild stuff, my Downloads folder had become a crime scene — installers next to screenshots next to half-finished PSDs next to who-knows-what .crdownload files. I didn't want a one-off cleanup, I wanted something that ran itself: scan, sort into sane category folders, flag junk instead of nuking it, and let me undo anything if it got something wrong. So I built Prism Organizer — a CLI first, then a full arrow-key TUI dashboard on top, because typing --recursive --no-interactive at 1am is not a personality trait I want.

By this week it had scan, sort-by-type/date, three-phase duplicate detection (size → partial hash → SHA-256, plus perceptual hashing for near-duplicate images), a custom YAML rules engine, optional AI classification (OpenAI, Ollama, or LM Studio — your choice, local-first if you want it), and a watch mode. What it didn't have, in any way I'd actually tested end-to-end, was the one feature that made all of that automatic: schedule add.

Bug #1: The Python That Wasn't There

First attempt at registering the schedule, python -m prism_organizer schedule add ..., threw a native Windows dialog: python314.dll was not found. Not a bug in my code — a half-broken Python 3.14 install shadowing a perfectly good Python 3.13 sitting one directory over. py -0p showed both; py -3.13 fixed the immediate problem in about ten seconds. Lesson filed under "always check where python before blaming your own code," and moving on.

Bug #2: The `--command` That Ate Itself

The second failure was more interesting, and entirely mine. I'd typed:

prism-organizer schedule add "C:\Users\...\Downloads" --command sort --interval monthly --days 1,15 --at 09:00

and got a stack trace from cmd_sort — a function that shouldn't have run at all, crashing on AttributeError: 'Namespace' object has no attribute 'by'.

The root cause was an argparse collision I'd shipped without noticing: my top-level subcommand parser used dest="command" (so args.command holds "scan", "sort", "schedule", etc.), and the schedule add subparser also defined a --command flag for "which action should this scheduled task run" — writing to that exact same args.command attribute. Parse schedule add ... --command sort and the nested flag silently overwrites the top-level one. By the time main() did commands.get(args.command), it was dispatching to cmd_sort with a Namespace that had never seen --by. Cloud-drive detection even kicked in as a side effect, since that's cmd_sort's job, not schedule's — which made the failure look far stranger than it was until I traced the actual attribute write order.

The fix: give the nested flag its own dest="run_command" so it stops colliding, update cmd_schedule() to read that instead, and add a regression test that literally asserts args.command == "schedule" after parsing schedule add. [confirm exact version/commit tag for this fix — v1.3.1] This is the kind of bug that only shows up when you actually run the command end-to-end instead of unit-testing each parser branch in isolation — which is exactly why it survived undetected through the initial release.

Bug #3: `schtasks` Doesn't Do Lists

With dispatch fixed, the tool correctly reached real Windows Task Scheduler — and Windows itself rejected the request: ERROR: Invalid value for /D option. I'd assumed schtasks /Create /SC MONTHLY /D 1,15 would register a single task firing on both days, the way you might expect from cron-style day lists. It doesn't. /D under /SC MONTHLY accepts exactly one numeric day. I confirmed it the boring, reliable way — ran the raw command by hand with a single day first, watched it succeed, then knew exactly what to build.

The real fix: TaskScheduler.add_task() now loops over each requested day and registers one schtasks entry per day — Prism Organizer - sort Downloads (day 1), (day 15) — with partial-failure handling so one bad day doesn't sink the whole batch, plus a group_base_name() helper so schedule remove can still treat them as one logical group instead of two mystery entries. Six new tests, full suite green at 45, shipped as v1.3.2.

What I'd Do Differently

Honestly, I'd have caught bug #2 in about thirty seconds if I'd run schedule add against a real Windows Task Scheduler once before calling the feature "documented and done" in the README. It's a classic trap: the individual pieces — argument parsing, task creation, task listing — all had unit coverage, but nothing exercised the actual dispatch path end-to-end with real subcommand strings. I've since made "run the exact command from the README, on a real machine, before merging" part of how I sign off on CLI features, not just an afterthought.

I also went back through the rest of the codebase with the same skeptical eye while I was in there, since I was about to make this public — and found one more real issue worth fixing before launch: the AI classification feature builds a destination folder path directly from whatever category string the model returns, with no sanitization, while the AI-rename path does sanitize. Same class of bug as the scheduling one, really — one code path got the careful treatment and a sibling path didn't. Fixing that now, before v1.3.2 becomes the version people actually pull down.

Try It

Prism Organizer is MIT-licensed and up on GitHub now: github.com/J-Akiru5/prism-organizer. npm install -g prism-organizer gets you a standalone binary with zero Python setup, or clone it and pip install -e . if you want to poke at the source. Dry-run is the default on every destructive command, nothing gets permanently deleted without an explicit backup folder, and prism-organizer undo reverses anything that goes sideways.

If you try it, or find bug #4, I'd genuinely like to hear about it — open an issue, or find me at jeffdev.studio / Syntaxure Labs.

Knowing vs. Understanding: What Two Physics Teachers Taught Me at AI Fest 2026

Jeff Martinez — Sat, 08 Aug 2026 15:23:33 +0000

"A booth conversation at AI Fest 2026 in Iloilo turned into a hard look at what it actually means to 'know' something — as a teacher, and as a developer gating five AI agents' output."

The Booth, the Noise, and Two Teachers Who Asked the Right Question

I spent August 3–5 at AI Fest 2026 in the Iloilo Convention Center, exhibiting under KWADRA TBI Cohort 5, representing Syntaxure Labs. Three days of pitching, demoing, and explaining "governance over generation" to anyone who'd stop long enough to listen.

Somewhere in the noise, two women stopped by the booth. Both DOST scholars. Both physics teachers, working on their master's degrees. And — as it turned out — both building a startup of their own, called Dalubasa, focused on early childhood literacy.

They weren't there for the AI pitch. They wanted to talk about kids.

"Knowing How To Doesn't Always Mean Understanding It"

Their startup idea came out of something they kept seeing in their own classrooms: young learners can speak English fluently — but that fluency is often pure imitation. The words come out right. The grammar lands. But shift the context slightly, ask a follow-up question the kid hasn't rehearsed, and the understanding underneath isn't actually there.

They put it simply, standing right there at the booth:

"Knowing how to doesn't always mean understanding it."

Coming from two physics teachers, that line hit different. Physics is basically the discipline built around catching people who can plug numbers into a formula and get the right answer without having the faintest idea why the formula works. Every physics teacher has graded that exam — a student nails F = ma on every problem set, then freezes the second you ask what force actually means in a scenario they haven't memorized yet.

Turns out five-year-olds learning English and physics students learning mechanics are doing the exact same move: pattern-match the surface, skip the model underneath.

Which Is When I Remembered I Do This For a Living

I build software. More specifically, these days I mostly architect it — I run a multi-agent pipeline where one model scaffolds, another handles the genuinely hard parts, another does quick edits, another builds frontend UI, another reasons through tradeoffs, and I sit on top of all of it as the gating reviewer deciding what actually ships.

Which means what those two teachers described isn't just a kids-learning-English problem, or a physics-101 problem. It's my problem too — just one layer up. I'm not the one typing every line anymore. I'm the one deciding whether the line that got typed is actually right, and that call is only as good as how deeply I understand what's underneath it — not how fluently I can skim a diff and think "yeah, that looks fine."

Fluency and understanding look identical from the outside. A kid saying a perfect English sentence looks the same whether they understand every word or none of them. A pull request that passes CI looks the same whether the person approving it understands the failure modes or is just pattern-matching "this looks like code I've seen before." The gap only shows up under pressure — a follow-up question, an edge case, a context nobody planned for.

That's the expensive version of "looks right." And it's exactly the version that agent-assisted development multiplies, because now there's more fluent-looking output to gate, faster, than any one person used to have to review.

The Actual Lesson

I don't think the answer is "understand everything, all the way down" — nobody does that, ever. I don't understand Postgres's internals well enough to rebuild them, and I use Supabase daily anyway. The physics teachers don't re-derive quantum field theory before teaching torque.

The lesson is narrower than that, and more useful: know exactly which layer you're responsible for understanding, and don't let fluency at the layers above or below it convince you that you've got it covered. For a kid learning English, that's whether they know what the words mean, not just how they sound. For a physics student, it's whether they know why the equation holds, not just how to rearrange it. For me, sitting on top of a handful of models producing code I didn't type — it's whether I understand the architecture and the failure modes well enough to catch it when something fluent is also wrong.

Two physics teachers reminded me of that at a booth in Iloilo, in between demos, completely by accident. Sometimes the most useful thing at a tech conference isn't the tech.

Have you run into your own version of this — fluent output masking a gap in real understanding, whether in code, in a classroom, or somewhere else entirely? I'd like to hear it in the comments.

I built complex web apps, but missed a simple UI paradigm hiding in plain sight

Jeff Martinez — Fri, 24 Jul 2026 15:37:00 +0000

As a developer, it’s easy to get trapped in a hyper-focused bubble.

I spend most of my days inside VS Code, architecting web systems, writing Next.js code, tuning AI development tools, and thinking heavily in terms of modular UI. Component-driven architecture—props, state, reusability—is literally second nature to me. If you ask me to build a dynamic platform or structure a front-end interface from scratch, I can map out the components before I even write the first line of JSX.

Yet somehow, I completely missed how fast everyday digital tools were evolving right under my nose.

Recently, I had to jump back into quick digital editing and media creation for a few community and project graphic assets. Naturally, I opened Canva—a tool I mostly remembered as a simple drag-and-drop graphic builder for quick posters.

That was until I started poking around its newer features and realized Canva now heavily utilizes components, dynamic properties, and bulk-editing capabilities.

💡 The realization: As developers, we get so absorbed in low-level mechanics that we overlook how consumer-level creative tools are quietly adopting the exact same component paradigms we preach in code.

Why Canva’s components hit close to home for a Next.js dev

When you work with Next.js or React, the core philosophy is reusability and a single source of truth. You build a core component (like <Card /> or <Button />), pass different props to it, and render dynamic content cleanly across your app without repeating yourself.

Seeing this paradigm inside a visual design suite was an instant "aha!" moment for me:

Component-Based Thinking: Instead of treating every slide as isolated static shapes, elements act as structured, reusable blocks. Update the core design once, and changes cascade across the project.
Bulk Editing & Data Mapping: The real mind-blower was the bulk editing efficiency. It’s essentially mapping an array of data over a visual component template—the exact same way we use .map() on JSON data in React.
Efficiency Over Manual Labor: As someone juggling software builds, community initiatives, and creative media, time is always a constraint. Leveraging modular logic inside a design canvas blew my workflow wide open.

The Developer's Dilemma: Don't ignore high-level tools

This little realization was a good humble pie for me.

We sometimes fall into the trap of thinking that if a tool doesn't require a terminal, custom code, or a complex build step, it’s "too simple." But efficiency is efficiency. Knowing how systems are engineered makes you appreciate when a visual tool gets abstraction right.

It reminded me that staying "tuned into technology" doesn't just mean reading documentation for the newest JavaScript framework or chasing AI models. It also means exploring how everyday software is solving workflow friction for creators.

If you’re a dev who hasn't looked at visual editing suites in a while because you assumed they were just basic design tools—give them another look. You might just find the component patterns you write in your codebase already working hard in a visual editor near you.

💭 Let's Chat

Have you ever had a moment where a simple visual tool surprised you with features you usually only write in code? Drop your thoughts below!

Building a Cyberpunk Portfolio with React, Cloud Run, and Gemini AI

Jeff Martinez — Mon, 02 Feb 2026 06:59:31 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI.

Introduction: Breaking the Mold

Hi, I'm Jeff. I'm a 3rd Year BSIT Student, Student Body President, and a freelance developer known as the "Vibe Coder."

I exist in the chaotic intersection of grinding out freelance deadlines and building "self-hosted" solutions at 3 AM. When it came time to build my portfolio, I refused to use a sterile, corporate template. I wanted to express the struggle and joy of coding through a Retro-Futuristic / Cyberpunk lens—a love letter to the 8-bit era, rebuilt with the tech of 2025.

The result is a containerized application running on Google Cloud Run, powered by a custom Gemini AI integration.

The Portfolio

JeffDev Studio | Vibecoder Developer

Portfolio of Jeff Martinez - Specializing in High-Performance Web Applications, React Architecture, and 8-bit aesthetic designs.

gcp.jeffdev.studio

(Note: If the embed above doesn't load, check out the live site at gcp.jeffdev.studio)

🔗 Quick Links:

Live Site: gcp.jeffdev.studio
Source Code: GitHub Repository

1. The Vision: Design with a Soul

I didn't write a single line of code until I had defined the "vibe." I spent hours in Figma mapping out an experience that felt like stepping into a futuristic arcade cabinet.

The Palette: Electric cyan, neon green, and deep space purples.
The Aesthetic: Pixelated fonts, glowing terminals, and nostalgic scanlines.

The Goal: Make it feel like a game, not a resume.

To ensure quality, I established strict design rules:

Retro-Futurism Only: Every component must pass the "vibe check."
Enhance, Don't Distract: Animations serve the content, they don't bury it.
Inclusive Design: Accessibility is non-negotiable.

2. The "Antigravity" Workflow

Building this solo meant I needed a force multiplier. I used my "Antigravity" workflow: treating AI not as autocomplete, but as a Senior Pair Programmer.

I didn't just prompt "make a website." I fed the AI my design rules and "laws of physics" for the UI. It helped me scaffold the architecture and solve complex CSS specificity wars for the CRT monitor effects.

The Tech Stack

Frontend: React 19 + Vite (for speed).
Animation: GSAP + ScrollTrigger (for buttery-smooth reveals).
Backend: Firebase Firestore (Real-time data) + Auth.
Hosting: Google Cloud Run (Dockerized).

3. The Crown Jewel: Gemini-Powered Intelligent Editor

I hate staring at blank Markdown files. I wanted a smart writing partner built directly into my portfolio's admin panel.

The Architecture:
User Chat → Intent Detection (Regex) → Gemini 2.5 Flash API → Diff Preview

Intent Detection & Diff Previews

Using regex pattern matching and Gemini's natural language understanding, the system distinguishes between:

Conversational Questions: ("Is this clear?") → Returns a chat reply.
Edit Requests: ("Fix the grammar") → Returns a structured code block.

When an edit is requested, I don't just apply it blindly. The system generates a Green/Red Diff Preview, allowing me to granularly accept or reject changes.

Why Gemini 2.5 Flash? It's fast, incredibly affordable, and its large context window allows it to remember the entire history of the post I'm writing.

4. Deploying on Google Cloud Run

To enter the "New Year, New You" challenge, I graduated from static hosting to Google Cloud Run.

The Docker Journey

I built a multi-stage Dockerfile:

Build Stage: Compiles the Vite app.
Production Stage: Copies assets into a minimal Node.js image (140MB) running a lightweight Express server.

⚠️ The Environment Variable Gotcha

I encountered a critical bug: my Firebase keys were undefined in the production build despite being passed as Docker arguments.

The Fix: Vite doesn't bake environment variables into the client bundle unless explicitly told to. I had to use the define option in vite.config.js:


javascript
// vite.config.js
define: {
  'import.meta.env.VITE_FIREBASE_API_KEY': JSON.stringify(env.VITE_FIREBASE_API_KEY),
}
Now, my pipeline is fully automated via GitHub Actions. Every push to main builds the container and deploys to Cloud Run in under 4 minutes.

5. Performance Meets Aesthetics
A site with neon glows and scanlines shouldn't be slow.

Lighthouse Scores: 98/100 Performance, 100/100 Accessibility.

First Contentful Paint: ~0.8s.

Accessibility: Full keyboard navigation and support for prefers-reduced-motion.

Final Thoughts
This project taught me that the best way to learn is to build for yourself without compromises. The intersection of retro aesthetics and modern cloud infrastructure might seem odd, but that's the point. We need more personality in our portfolios.

Go build something that makes you smile every time you look at it.

Created for the Google AI Dev.to Challenge.

How I Built My 8-Bit Portfolio with Claude Opus 4.5 on Antigravity

Jeff Martinez — Sat, 17 Jan 2026 22:13:00 +0000

Building a developer portfolio in 2025 feels different than it did just a year ago. The tools have evolved, AI has become a legitimate coding partner, and the line between "designing" and "developing" has blurred in the most exciting ways. This is the story of how I built my retro-futuristic portfolio—and how an AI assistant named Claude became my most reliable pair programmer.

The Vision: Cyberpunk Meets Nostalgia

My long-standing fascination with the aesthetic of old-school video games and the neon-soaked visuals of cyberpunk fiction naturally guided my vision. When rebuilding my portfolio, I aimed to create a digital experience that felt like stepping into a futuristic arcade—a place brimming with pixelated fonts, glowing terminals, and nostalgic scanlines. The challenge was to seamlessly blend all that retro charm into a modern React application.

The challenge was making it more than just a gimmick. A portfolio needs to be functional first. It needs to showcase real work, be accessible, and actually help me connect with potential collaborators and employers. The 8-bit aesthetic had to enhance the experience, not get in the way of it.

Starting with Design, Not Code

Before writing a single line of code, I spent time in Figma mapping out the experience. I'm a firm believer that jumping straight into code leads to endless refactoring later. Having a visual reference meant I could make design decisions without the pressure of implementation looming over me.

The design process helped me establish the color palette—electric cyan, neon green, sunset orange, and deep space purples against dark backgrounds. I mapped out the sections: a dramatic hero with my name in pixelated glory, an about section that tells my story, a skills showcase with animated progress bars, projects displayed as terminal windows, and a contact form styled like a command-line interface.

Enter Claude: My AI Pair Programmer

Here's where things got interesting. I'd been experimenting with AI coding assistants, but my experience with Claude Opus 4.5—specifically through an agentic coding platform called Antigravity—was different from anything I'd tried before.

Instead of treating the AI as a fancy autocomplete, I approached it as a true collaborator. I described what I wanted to build, shared my design files, and watched as Claude helped me scaffold the entire React project structure. It suggested component architecture, helped me set up GSAP animations, and even caught accessibility issues I would have missed.

The magic wasn't just in code generation—it was in the back-and-forth. When something didn't look right, I could describe the problem in plain English. When I wanted to add a feature like a typing animation for my tagline, Claude didn't just write the code; it explained the approach and suggested alternatives I hadn't considered.

Bringing It to Life with Animation

A static portfolio feels lifeless, especially one going for a retro-gaming vibe. I leaned heavily on GSAP and ScrollTrigger to create those moments of delight—the hero section with its dramatic reveal, skill bars that fill as you scroll past, project cards that float in with staggered timing.

One of my favorite touches is the holographic projector in the hobbies section. Hover over a hobby category and watch the CRT monitor flicker to life with details about that interest. Small interactions like this transform a portfolio from a static resume into an experience people actually want to explore.

The Technical Stack

For those curious about what powers this site: it's built with React and Vite for fast development and builds. Styling is vanilla CSS with CSS variables for the theme system. Animations are handled by GSAP with ScrollTrigger for scroll-based effects. The backend uses Firebase for the contact form and any dynamic content. Everything is deployed on Vercel with automatic previews for every push.

I intentionally kept the stack simple. Fancy frameworks are great, but for a personal portfolio, I wanted technology that would be easy to maintain and update years from now. React and CSS aren't going anywhere.

Lessons from the Process

Building this portfolio taught me a few things worth sharing. First, AI-assisted development is genuinely powerful when you treat it as collaboration rather than delegation. I still made every design decision and wrote plenty of code myself, but having an intelligent assistant to bounce ideas off accelerated the whole process.

Second, constraints breed creativity. The 8-bit theme could have been limiting, but it actually made decisions easier. Every component had to pass the "does this feel retro-futuristic?" test. That focus prevented feature creep and kept the design cohesive.

Third, accessibility still matters, even with a gimmicky aesthetic. The portfolio works with screen readers, respects reduced-motion preferences, and maintains proper color contrast despite all the neon. Good design is inclusive design.

What's Next

A portfolio is never truly finished—it evolves as you do. I'm already planning to add a blog section for deeper technical writing, integrate some live project demos, and continue refining the animations based on feedback.

If you're thinking about building your own portfolio, my advice is simple: have fun with it. This is the one website where you get to be completely yourself. Make it weird, make it personal, make it something you're proud to share. And if you've got an AI assistant ready to help, don't be afraid to lean on it. The future of development is collaborative—even when your collaborator is a large language model.

Please check out my personal portfolio https://portfolio.jeffdev.studio/ for more info about me and blog posts

DEV Community: Jeff Martinez

Shipping Prism Organizer: How Scheduling My Own Cleanup Tool Found Three Bugs in One Afternoon

Shipping Prism Organizer: How Scheduling My Own Cleanup Tool Found Three Bugs in One Afternoon

TL;DR

Why I Built This in the First Place

Bug #1: The Python That Wasn't There

Bug #2: The --command That Ate Itself

Bug #3: schtasks Doesn't Do Lists

What I'd Do Differently

Try It

Knowing vs. Understanding: What Two Physics Teachers Taught Me at AI Fest 2026

The Booth, the Noise, and Two Teachers Who Asked the Right Question

"Knowing How To Doesn't Always Mean Understanding It"

Which Is When I Remembered I Do This For a Living

The Actual Lesson

I built complex web apps, but missed a simple UI paradigm hiding in plain sight

Why Canva’s components hit close to home for a Next.js dev

The Developer's Dilemma: Don't ignore high-level tools

💭 Let's Chat

Building a Cyberpunk Portfolio with React, Cloud Run, and Gemini AI

Introduction: Breaking the Mold

The Portfolio

JeffDev Studio | Vibecoder Developer

1. The Vision: Design with a Soul

2. The "Antigravity" Workflow

The Tech Stack

3. The Crown Jewel: Gemini-Powered Intelligent Editor

Intent Detection & Diff Previews

4. Deploying on Google Cloud Run

The Docker Journey

⚠️ The Environment Variable Gotcha

How I Built My 8-Bit Portfolio with Claude Opus 4.5 on Antigravity

The Vision: Cyberpunk Meets Nostalgia

Starting with Design, Not Code

Enter Claude: My AI Pair Programmer

Bringing It to Life with Animation

The Technical Stack

Lessons from the Process

What's Next

Bug #2: The `--command` That Ate Itself

Bug #3: `schtasks` Doesn't Do Lists