DEV Community: pan

I Built an zero touch or automatic AI Time Tracker Because I Was Too Lazy to Track My Time 💀

pan — Mon, 26 Oct 2026 06:05:10 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Recently, I was reading The Now Habit, a book about overcoming procrastination. It discussed something surprisingly simple: track where your time goes before trying to change how you spend it.

Makes sense, right? So I decided to start tracking my time on paper, following one of the examples in the book.

And then I did what any dedicated procrastinator would do.

I procrastinated on tracking my procrastination. 💀

Think about it. I was trying to stop wasting time, but the very first step required me to remember to write things down every time I switched tasks. Open a notebook, write down the task, note the time, remember to stop the timer, start another one…

Bro, I needed a project manager just to manage the process of managing my time.

So naturally, instead of doing the sensible thing and simply writing things down, I spent my time building an entire application to do it for me. 😂

Meet Time Tracker AI 2.0 — an automatic, AI-powered Windows time tracker built around one rule:

Zero steps to record your time. Your computer does the tracking; you do your thing.

It quietly observes what I'm doing on my computer, records activity, identifies applications and websites, classifies tasks, builds a timeline, calculates productivity metrics, and alerts me when my actions don't match my plans.

No manually starting timers. No reconstructing my entire day from memory at midnight. No spreadsheet that I enthusiastically create and abandon three days later.

What can it actually do?

1. Automatic activity tracking

The tracking engine continuously monitors my active Windows application, window title, activity duration, and idle periods in the background.

Automatically records application usage without requiring manual timers.
Detects idle periods based on keyboard and mouse activity, without recording the actual keys I type.
Tracks when applications change and merges consecutive observations into longer activity records.
Supports starting, pausing, resuming, and stopping tracking.
Protects against duplicate tracking processes and includes recovery mechanisms for interrupted observations.

The raw observation loop runs at approximately one-second intervals. The application combines those observations into useful records rather than presenting every second as a separate task.

2. Automatic browser and website tracking

An application name alone doesn't tell me much. Spending an hour in Chrome could mean studying Python, watching chess videos, browsing Reddit, or falling into a YouTube rabbit hole.

Time Tracker AI tracks browser activity and attributes it to individual websites.

It supports Chrome, Edge, Brave, Opera, Opera GX, Vivaldi, and Firefox through Windows accessibility automation and fallback title parsing.

It can associate browser activity with website domains and page titles without requiring a dedicated browser extension. Captured URLs are sanitized to remove query parameters and fragments.

The objective is to understand not just which application I opened, but what I was actually doing inside it.

3. Two-layer smart activity recognition

Raw activity records aren't very useful until they have context.

The application uses a rule-based classification pipeline first. It checks manual corrections, URL rules, website domains, application names, and window-title patterns in priority order.

For more ambiguous activity, optional AI-assisted classification using the Gemma model family can provide richer descriptions and categories.

The result is a structured activity record rather than a long list of cryptic executable names.

I can also create custom categories and rules, adjust how applications and websites are classified, and correct mistakes directly from the timeline.

The system includes built-in categories for coding and development, research and learning, communication, utilities and system activity, entertainment, social browsing, uncategorized activity, and idle gaps.

4. Privacy-aware screenshot analysis

Sometimes an application title doesn't tell the whole story.

The project includes an optional vision-analysis path for ambiguous windows. When the configured Ollama vision service is available, screenshots can be analyzed to provide additional context about the activity.

A sensitive-application blacklist suppresses screenshot processing for configured windows and applications, including password managers, authentication tools, banking-related windows, and other sensitive contexts.

The vision functionality is optional. Core time recording doesn't require an AI vision model to be running.

5. A timeline that makes sense

Recording thousands of observations is easy. Turning them into a readable story of the day is the harder part.

The interactive timeline groups related observations into sessions and helps distinguish between different kinds of activity.

It includes:

Clustered View: A cleaner, human-readable view of longer sessions.
Detailed View: A granular view of the underlying observations.
Search and category filters.
Timeline zoom controls and chronological navigation.
Session details, including duration, application, title, website, and confidence information.
Warnings for uncertain classifications.
Manual editing of session descriptions and categories.
Custom rules that make future classification more consistent.

Manual corrections are saved so that corrected classifications can take precedence over automatic classifications when the timeline is loaded again.

6. Productivity analytics and reports

This is where all that tracking becomes useful.

The dashboard provides an overview of focused work, productive work, distraction time, and daily goal progress, including comparisons against the previous day.

The analytics section lets me investigate my activity across today, yesterday, the last seven days, the last 30 days, this week, this month, and custom date ranges.

It includes:

Productivity and focus metrics.
Distraction-time breakdowns.
Hourly activity visualizations and focus-versus-distraction patterns.
App usage and website-domain breakdowns.
Top Interruptors, which help identify applications and idle gaps associated with fragmented work.
A calculated Productivity Score.
Comparisons across different dates and reporting periods.

Instead of guessing whether I spent the day productively, I can inspect the data and see where my time actually went.

7. Time blocking, focus sessions, and goals

Tracking what happened is only half the problem. I also need to compare it with what I intended to do.

The time-blocking system lets me schedule a task, specify its start time and duration, and assign a target category.

I can:

Create, edit, duplicate, shift, and delete time blocks.
Choose quick durations such as 25, 50, or 90 minutes, or set a custom duration.
Detect overlapping blocks before saving.
Start a focus session associated with a planned block.
Review plan adherence and see how much of the scheduled period matched the intended activity.
Set daily targets for work, focus, study, and distraction limits.

The important distinction is that a planned task and a recorded task aren't treated as the same thing. The tracker can compare what I intended to do with what actually happened.

8. Smart Windows notifications and accountability

This is one of my favourite features because it helps close the gap between making a plan and following it.

Time Tracker AI can generate native Windows notifications for:

Upcoming and starting time blocks.
Sustained activity that doesn't match the planned task.
Prolonged idle periods.
Missed-activity gaps that may need to be filled in after returning to the computer.

The notifications support relevant actions, such as starting a focus session, snoozing an alert, skipping a block, opening the planner, reviewing activity, or switching tasks.

It also includes configurable notification preferences, idle thresholds, notification sounds, quiet hours, and a notification history.

The notification logic includes grace periods, cooldowns, and suppression rules to reduce unnecessary alerts.

If I return after being away for a long time, the application can offer a recovery prompt so I can manually add activity that wasn't recorded. It doesn't need to pretend it knows exactly what happened while I was gone.

The aim is accountability without turning my desktop into a notification factory.

9. An AI productivity coach

The project includes an AI Coach for questions about my day.

It supports structured queries about productivity summaries, distractions, focus, goals, time blocks, and activity breakdowns. These common questions can be answered using metrics obtained directly from the local database.

For more open-ended questions, the application can use an available Ollama language model, with verified activity metrics supplied as context.

If the model isn't available, supported requests can return a deterministic summary of the available data instead.

The purpose isn't to let a chatbot invent productivity statistics. It's to make the information already collected easier to understand and act on.

The coach also has suggested prompts and navigation actions that can take me directly to relevant parts of the application.

10. A floating desktop widget

I don't want to keep opening my dashboard just to check my active session.

The floating mini-widget stays on top of other windows and provides a compact view of my tracking status.

It displays the active task, elapsed session time, and daily progress. It supports expanded and compact layouts, tracking controls, task editing, and saved window positioning.

That means I can keep it visible while coding, browsing documentation, or working in a terminal without constantly switching away from what I'm doing.

11. Data export, settings, and recovery

The application also includes the less glamorous features that make a real tool usable.

CSV exports: Download detailed activity records or summaries of application and website usage for a selected date range.
Settings: Configure notification behaviour, quiet hours, idle thresholds, and other preferences.
Profile management: Edit the local user profile.
Autostart: Optionally launch the application when logging in to Windows.
Local diagnostics: Inspect database-related information to help troubleshoot the tracker.
Persistent storage: Keep observations, activity classifications, time blocks, goals, notifications, settings, and reports in SQLite.
Recovery mechanisms: Audit and repair certain interrupted or unfinished observations.

12. A standalone Windows application

I didn't want the final product to be just another development server that needed to be opened in a browser.

The project combines a Python backend, a React and TypeScript interface, FastAPI, SQLite, and PyWebView into a dedicated Windows desktop application.

It includes a custom desktop title bar, minimize and maximize controls, window management, a single-instance mechanism, and lifecycle handling for closing the application while tracking is active.

The project also has Windows packaging and installer scripts, desktop and Start Menu shortcuts, an uninstaller, and support for opening the application through notification actions.

The intended experience is a proper desktop application rather than a website I have to remember to open.

Demo

Demo video: https://youtu.be/XNiH-a5P9Zg?si=oiFGwKcNzyiUlEWK

Code

GitHub repository: Time Tracker AI 2.0

The project is built primarily with Python, React, TypeScript, FastAPI, SQLite, and PyWebView.

How I Built It

The architecture separates the Windows tracking engine from the API, database, AI-assisted interpretation, and desktop interface. The tracking engine collects observations, the database stores them, the backend calculates metrics and handles classification, and the frontend presents the results.

Where AI fits in

I use Ollama-compatible models, including the Gemma model family, for optional AI-powered activity interpretation and related features. The project also contains a Llama 3.2 configuration for open-ended AI Coach queries.

The Gemma-related paths support text interpretation, optional vision analysis, and natural-language productivity summaries, depending on their configuration and availability.

I deliberately kept deterministic logic at the centre of the application. Recording an observation, calculating a duration, checking a scheduled time block, or aggregating a report doesn't inherently require an LLM.

AI is used where interpretation can add value. Rules and database calculations handle the tasks that are better suited to deterministic logic.

This hybrid design also means that losing access to a model doesn't have to stop the core tracker.

Why Does Open Innovation Matter?

I'm a student, and I don't have an unlimited budget for building software.

I want to experiment with AI, build real projects, and keep iterating. But sending every classification and analysis request to an expensive closed API can make experimentation costly, particularly for a product that runs continuously.

Open-weight models give me more flexibility.

With an appropriate local model and compatible hardware, I can run inference without paying a per-token fee to a hosted API. I can experiment with different models, control the configuration, and decide which operations actually benefit from AI.

Cloud-hosted model options are useful too, but they can require network access and may have different costs or authentication requirements. The important part is being able to choose how each feature is implemented.

Open models also let me learn by exploring how inference fits into a real application instead of treating an AI API as a magic box.

For someone building independently on a student budget, that freedom matters. It lowers the cost of experimentation and makes it easier to turn an idea into something practical.

The Lazy Payoff

The biggest payoff is that I no longer have to remember to start and stop timers every time I switch tasks. Earlier, I'd start a timer, move to another task, and completely forget to stop the original one. Suddenly, my two-hour coding session somehow lasted six hours. My time tracking was tracking fiction. 💀

Now I can sit down to code, research a topic, or watch a tutorial, and the tracker records the activity in the background. Later, I can inspect the timeline, review my productivity, find interruptions, export the data, and compare my actual behaviour against the schedule I made.

And when I plan to spend an hour studying but drift into unrelated activity, the application can help me notice that mismatch before the end of the day.

It's not going to magically cure my procrastination. Unfortunately, no amount of Python can guarantee that I won't find a new way to waste three hours.

But it removes one excuse: I can't procrastinate on tracking my time when the tracking happens automatically.

I started this project because I wanted to build a habit from The Now Habit. Somewhere along the way, that simple attempt turned into a much larger experiment in Windows automation, data analysis, AI, and product development.

The project is still evolving, but that is the idea behind Time Tracker AI 2.0: make tracking effortless, make the data useful, and make it easier to notice when my actions don't match my intentions.

And hopefully, spend less time building increasingly elaborate systems to help me stop wasting time.

Although, looking at this project, I may need to build a tracker for the time I spend building trackers. 💀

Prize Categories

Best Use of Gemma

The project uses the Gemma model family for optional AI-powered activity interpretation and related analysis paths. Rather than sending every observation to an AI model, I combine model-assisted interpretation with deterministic tracking, classification rules, and local analytics.

That hybrid approach lets AI add context where it's useful while keeping core tracking and reporting functional without constant model inference.

Best Use of GitHub Copilot
GitHub Copilot helped me understand unfamiliar code, explore implementation ideas, debug errors, and refine features while building this project as a student.

It made development faster and helped me learn along the way, but testing and fixing things when they broke was still on me! 🚀

But it removes one excuse: I can't procrastinate on tracking my time when the tracking happens automatically.

I started this project because I wanted to build a habit from The Now Habit. Somewhere along the way, that simple attempt turned into a much larger experiment in Windows automation, data analysis, AI, and product development.

The project is still evolving, but that is the idea behind Time Tracker AI 2.0: make tracking effortless, make the data useful, and make it easier to notice when my actions don't match my intentions.

And hopefully, spend less time building increasingly elaborate systems to help me stop wasting time.

Although, looking at this project, I may need to build a tracker for the time I spend building trackers. 💀

Prize Categories

Best Use of Gemma

That hybrid approach lets AI add context where it's useful while keeping core tracking and reporting functional without constant model inference.

Best Use of GitHub Copilot

GitHub Copilot helped me throughout the process of turning this idea into a working application.

As a student, I'm still learning how to design and maintain larger software projects. Building a system that combines Windows APIs, background processes, a database, a backend, a React interface, AI integrations, and desktop packaging meant dealing with plenty of unfamiliar code and concepts.

Copilot helped me think through implementation approaches, understand existing code, explore unfamiliar functions, and translate ideas into concrete code changes. It was also useful when working through errors, refining implementations, and understanding how different parts of the application fit together.

One of the biggest benefits was being able to investigate why something worked instead of blindly copying a solution. Understanding why matters when multiple components need to communicate reliably.

AI-assisted development wasn't a magic button, either. Suggestions still needed to be inspected, tested, and debugged. Sometimes a fix introduced a new issue, or the initial diagnosis turned out to be wrong. That meant iterating: understand the problem, explore a solution, implement it, and verify the result.

For me, Copilot was less about generating an entire application with one prompt and more about accelerating the development and learning process. It helped me work through unfamiliar technical challenges while learning about software architecture, debugging, integration, and product development along the way.

The biggest lesson was that AI assistance is most useful when it helps you understand and improve your work, not when you stop questioning its output.

Hello, any chess players out there? ♟️ I built something specifically for a problem I kept seeing while studying chess. Would love for you to check it out and tell me what you think!

pan — Mon, 05 Oct 2026 05:43:18 +0000

Hacktoberfest Weekend Challenge: Build for a Friend Submission 🤝

pan

Oct 5

♟️ Chess FEN-tastic: From Screenshot to Playable Chess Position in Seconds with Gemma

#devchallenge #weekendchallenge #hf26challenge

4 min read

♟️ Chess FEN-tastic: From Screenshot to Playable Chess Position in Seconds with Gemma

pan — Mon, 05 Oct 2026 05:35:51 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My friend recently started learning chess seriously.

He started reading chess books and watching grandmasters play, and there was one problem that kept coming up.

Almost every chess book, whether it's about theory, tactics, or positional chess, is filled with lots of positions to study — diagrams showing a position and asking you to understand the idea, find the move, or analyze what happens next.

But there’s a frustrating gap between seeing the position and actually analyzing it on a digital board.

He'd see something like this:

“White to move. Find the best continuation.”

Great.

Except the position is sitting there as a picture in a book.

To analyze it online, he has to manually recreate the position:

Find the board → identify every piece → place every piece → check the position → finally start analyzing.

Do that once? Fine.

Do it for hundreds of positions across multiple chess books?

Yeah. No.

That was the problem I wanted to get rid of.

So I built Chess FEN-tastic, using Gemma 4 Cloud to turn chess positions into structured, playable positions.

And yes, I know the name is a little... supercalifragilisticexpialidocious.

That's exactly why I chose it. Chess FEN-tastic is supposed to make something tedious feel ridiculously simple — so I wanted a name that was just as ridiculously fun.

Bring any two-dimensional chess position to a digital, playable board in one click — in 3–4 seconds.

Instead of manually rebuilding the position, you simply select it.

Gemma sees the board. Python converts it. Lichess makes it playable.

And suddenly that annoying gap between reading about a position and actually analyzing it on a board disappears.

Demo

🔗 Demo Video

Code

🔗 View the source code on GitHub

How I Built It

The interesting part of Chess FEN-tastic isn't generating FEN.

The real challenge is understanding the chess position inside the image.

A human can look at a chess diagram and immediately understand what's happening.

A computer sees pixels.

That's where Gemma 4 Cloud became the heart of the project.

I give Gemma the actual screenshot of the chess position and ask it to reconstruct all 64 squares.

It identifies:

♔ Which squares contain pieces
♟️ What type of piece is there
⚪ Whether each piece is white or black
⬜ Which squares are empty
🔄 Which side is to move

Instead of asking Gemma to directly produce a FEN string, I have it return a structured representation:

a8: black_rook
b8: empty
c8: black_king
...
h1: white_rook
side_to_move: white
...

This is an important design choice.

Gemma interprets. Python formalizes.

Gemma handles the part that requires visual understanding.

Python handles the part that should be deterministic.

The pipeline becomes:

       CHESS POSITION
             │
             ▼
        📸 SCREENSHOT
             │
             ▼
      🧠 GEMMA 4 CLOUD
             │
             ▼
     64 SQUARES RECOGNIZED
             │
             ▼
      STRUCTURED POSITION
             │
             ▼
       🐍 PYTHON → FEN
             │
             ▼
       ♟️ LICHESS BOARD

The AI isn't just sitting on top of the project as a chatbot.

Visual recognition is the actual core problem.

Without understanding the image, there is no position to convert.

What I really liked about using Gemma here is that I could take a powerful vision-language capability and apply it to a very specific problem.

I didn't want to build another generic AI assistant.

I wanted to solve a very small but surprisingly annoying problem:

How do you turn a chess position that a human can see into a chess position that a computer can use?

Gemma acts as the bridge between those two worlds.

It takes something visual and ambiguous — an image of a chessboard — and turns it into structured information my program can work with.

And the result is remarkably simple:

Image → Gemma → structured position → FEN → playable board

One screenshot.

One model.

One structured output.

One playable position.

That's what makes Gemma so important to Chess FEN-tastic.

Why Does Open Innovation Matter?

The biggest reason open innovation mattered for this project is accessibility and control.

I wanted to build a focused tool around a vision-language model without having to build an entire computer-vision system from scratch.

Gemma gave me a model capable of understanding the visual input, while Ollama provided the interface for integrating the model into my Python application.

That separation made the project possible as a small, focused experiment:

I could concentrate on solving the chess problem instead of reinventing visual recognition.

It also means the architecture isn't tied to a single application-specific chess API. The model interprets the image, while my own code controls the structured representation, validation, FEN generation, and final output.

The result is a simple combination of open technologies solving a very specific real-world problem.

Prize Categories

Best Use of Gemma — The heart of the project. Gemma turns a visual chess position into structured data, making the entire Image → FEN → playable board workflow possible.