TeachMyPC: I wanted file automation without giving AI control of my Mac

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

I have a habit of letting files pile up in my Downloads folder. PDFs, screenshots, random documents... and eventually I have to sit down and organize everything.

As a developer, I could write a script for that. But I don't really want to write and maintain a script every time I need something simple.

And not everyone knows how to write scripts in the first place.

So for this week's challenge, I built TeachMyPC, a macOS desktop app that lets you describe a file automation task in plain English (or Arabic!) and turn it into a reusable rule.

For example, I can write:

Move every new PDF file from my selected input folder to my selected output folder.

TeachMyPC uses a local AI model to interpret the instruction and prepare a rule. I can then review it, choose the folders, test it, and enable it when I'm ready.

After that, the app watches the selected folder and handles matching files automatically.

The important part for me was making sure that AI doesn't get to do whatever it wants on my computer.

It helps create the rule. It doesn't execute arbitrary commands.

What can it do?

The current version supports:

• Creating automation rules using natural language.
• Moving, copying, and renaming files.
• Filtering new files by extension.
• Reviewing and editing the AI-generated rule before saving.
• Testing a rule with Dry Run before actually using it.
• Enabling and disabling rules whenever needed.
• Viewing automation activity and results.

I also made new rules disabled by default. Nothing starts running just because the AI understood an instruction.

Who would pay for it?

I'm thinking of people who work with a lot of repetitive files: freelancers, designers, photographers, and small businesses.

Someone who regularly downloads client PDFs, exports files, or organizes screenshots probably doesn't need a complicated automation platform. They just want those small tasks handled.

My idea would be a simple paid desktop utility, possibly with a one-time license rather than another monthly subscription.

I haven't validated the pricing with real customers yet. That's something I'd like to explore after the challenge.

Demo

Video walkthrough: Watch TeachMyPC on YouTube

The walkthrough was recorded from the actual macOS app, with narration generated using ElevenLabs.

Here's the workflow I used for the demo:

1. I enter an instruction to move new PDF files.
2. Gemma interprets it into a rule that I can review.
3. I select the source and destination folders.
4. I save the rule, then run a Dry Run with a sample file to check what would happen.
5. I enable the rule and add a PDF to the watched folder.
6. The file moves to the destination, and the result appears in Activity.

The Dry Run part is worth showing because it lets me check the planned action without changing any files.

Reviewing the AI-generated rule

After Gemma interprets the instruction, TeachMyPC shows the generated rule in an editable form.

In this example, it identified a new-file trigger, a .pdf extension filter, and a Move action. I can review everything, change the rule name, or adjust the actions before continuing.

Testing before enabling

Once the rule is saved, it appears in the Automation Workbench, where I can check its status, authorized folders, and actions.

The screenshot below shows the rule still disabled, with a Dry Run preview for a sample PDF. I can see the planned destination without actually moving the file.

Checking what happened

After enabling the rule and adding files to the watched folder, TeachMyPC records the results in Activity.

Each entry shows what happened to a file, whether the operation succeeded, and details like its original and destination paths. This makes it easier to check what the automation actually did.

Code

GitHub: TeachMyPC source code

TeachMyPC is currently built and tested as a macOS desktop application. The repository includes the source code, setup instructions, and tests.

How I Built It

I'm mainly a frontend developer, so I started with Angular for the interface and used Tauri to turn it into a desktop app.

The stack is:

• Angular + TypeScript: the interface, rule creation, management, and activity views.
• Tauri 2 + Rust: native filesystem access, file watching, validation, and rule execution.
• Ollama + Gemma 3 4B: local interpretation of natural-language instructions.

The flow is basically:

Instruction → Local AI → Editable Rule → Validation → Dry Run → Enable → File Automation

One design decision I spent time on was separating the AI from the execution logic.

Gemma only translates an instruction into structured rule data. The Rust side checks what the rule is allowed to do and performs supported operations.

I didn't want a model generating shell commands and running them directly.

There are also some safeguards:

• A rule can only work with folders the user has explicitly selected and authorized.
• Dry Run previews the action without modifying the file.
• Existing destination files aren't silently overwritten.
• Unsupported destructive actions, like deleting files, aren't supported.
• Failed operations are reported instead of being treated as successful.

I spent part of the final day testing the actual macOS app, not just the Angular interface. That included creating a PDF move rule, testing authorized and unauthorized file paths, checking the Dry Run behavior, and enabling and disabling rules.

What was tricky?

Getting an AI model to return an answer wasn't the hardest part.

Making sure that answer was safe to use was.

For example, an instruction like "organize all my documents automatically" doesn't really tell the app what to do. What counts as a document? Where should the files go?

In testing, I found that Gemma could sometimes generate a rule for an ambiguous instruction instead of asking for more details.

That's a limitation I still want to improve. For now, the rule remains editable and disabled until the user reviews and explicitly enables it.

I also learned that testing a desktop app is quite different from testing a normal web application. A passing Angular test doesn't necessarily mean file watching and filesystem operations will behave correctly in the packaged app.

Why Does Open Innovation Matter?

For this project, running AI locally made sense from the beginning.

TeachMyPC deals with local folders and personal files. I didn't want people to need a cloud AI account just to organize those files.

With Gemma running through Ollama, the instruction can be interpreted on the user's machine without sending it to a hosted model API.

It also means there's no per-request API cost for interpreting rules, although running the model locally does require resources.

And because the model is open-weight, I can experiment with its prompts and behavior without depending on a closed provider.

I like that the AI part is replaceable, too. The filesystem engine doesn't have to change just because I want to try another model later.

To me, that's the useful part of open AI here: I can use it for understanding natural language while keeping the actual automation under my control.

What's Next?

There's still work to do before I'd consider TeachMyPC a product ready to sell.

I want to improve how it handles vague instructions, make the first-time setup easier, and test it with people who aren't developers.

I'd also like to explore more useful file conditions and rule templates without turning it into an overly complicated automation tool.

For now, I'm happy that I managed to get from a plain-English instruction to an actual file being moved on my Mac.

And yes, my Downloads folder could still use some cleaning.

Prize Categories

Best Use of Gemma

I used Gemma 3 4B through Ollama to interpret natural-language instructions and turn them into structured file automation rules.

Gemma doesn't execute commands or modify files directly. The generated rule goes through validation and requires user approval before it can run.

Best Use of ElevenLabs

I used ElevenLabs with the Lara voice to create the narration for my demo walkthrough.

I wanted the demo to feel like someone explaining a project they built, rather than a promotional video. ElevenLabs helped me put together a narrated walkthrough of the actual macOS application, from creating a rule to watching it work.

Comments

[Auten]

Disabled-by-default plus Dry Run is a better boundary than most "AI on my computer" designs I've seen. The model turns an instruction into a rule a person can read, and only the rule ever runs.

One thing I'd look at next is where the risk actually sits within the rule set. Move/copy/rename into a folder you picked is recoverable; an overwrite on a name collision during rename, or a move onto an external drive that is not mounted, can quietly lose a file. Do you keep an activity log detailed enough to undo a run (original path -> new path), and what happens when the destination already has a file with that name?

That "undo story" is probably also what a paying freelancer would ask about first: they trust automation once they know they can roll back a bad day.