LazyDeskOrg 🦥 — Less Time Organizing Notes, More Time Getting Things Done

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

What I Built

I built LazyDeskOrg because turning a pile of notes into something useful shouldn't feel like another task on my to-do list.

Think about a typical day: you write down an assignment deadline, a reminder to email someone, an idea you might explore later, and a few things you don't want to forget. Everything is there, but it's scattered. Before you can actually get to work, you have to sort it all out.

That's the small problem LazyDesk tries to solve.

LazyDeskOrg is a local-first productivity app that takes messy notes and turns them into organized task checklists or concise summaries. You paste your notes, choose Organize tasks or Summarize notes, and let AI help with the first draft. The result appears as Markdown, which you can download and use wherever you keep your notes.

But I wanted the app to do more than just rearrange sentences. Notes don't always contain definite plans. “Finish the assignment by Friday” is a commitment, “maybe review my AWS notes this weekend” is a possibility. Those shouldn't automatically be treated the same way.

LazyDeskOrg's prompts are designed to preserve that distinction and avoid inventing tasks or deadlines. The output still needs a human review, but it gives you a cleaner place to start.

The idea is simple: let AI handle some of the organizing, while you stay in control of the decisions.

Demo

Watch LazyDeskOrg in action:

In the demo, I'll show LazyDeskOrg running on my computer, organizing a set of messy notes, and downloading the result as a Markdown file.

I chose to keep the app local rather than deploy it just to demonstrate the idea. The important part is seeing the actual workflow and how the app behaves with real input.

Code

GitHub Repo:

Meher01 / LazyDesk

LazyDesk - Hacktoberfest Week 3 Dev Challenge

LazyDesk is a local-first productivity assistant that turns messy notes into organized Markdown. It uses a local Ollama model through a small Streamlit interface, so your notes are processed on your own computer instead of being sent to a hosted AI service.

Features

• Organize tasks into a Markdown checklist grouped under short headings.
• Summarize notes with a concise overview and key points.
• Preserves relative dates such as “next Friday” exactly as written.
• Keeps possibilities, questions, and uncertain statements tentative instead of turning them into committed tasks.
• Treats pasted notes as untrusted content and does not follow instructions embedded inside them.
• Validates Ollama responses and displays useful connection, timeout, and response errors.
• Download results as a Markdown file.

Requirements

• Python 3.10 or newer
• Ollama
• The qwen2.5:3b Ollama model

LazyDesk is configured to call Ollama at:

http://localhost:11434/api/generate

Installation

Clone the repository and create a virtual…

View on GitHub

_The repository contains the Streamlit app, the Ollama integration, the core prompt and response-handling logic, unit tests, and a GitHub Actions workflow that runs those tests.

I wanted the project to be more than a demo that works once on my machine. Keeping the core logic testable gives me a way to check important behavior as I continue developing it._

How I Built It

LazyDeskOrg is built with Python and Streamlit, with Ollama running the open-weight qwen2.5:3b model locally.

I chose this setup so I could experiment with AI-powered note organization on my own computer without depending on a hosted AI API. The app sends the notes to my local Ollama service, uses a prompt suited to the selected mode, and displays the generated Markdown.

One part of the project that mattered to me was making the logic easier to test.

I separated the prompt-building and response-validation functions into lazydeskorg_core.py and added standard-library unit tests in test_lazydeskorg_core.py. These tests check the core logic without having to start Ollama or download a model every time. That also makes it practical to run them automatically with GitHub Actions.

I used GitHub Copilot Agent to help with development tasks such as refactoring the core logic, working on the tests, and setting up the test workflow. I still needed to inspect the changes and run the tests rather than assume generated code was correct.

That combination was useful: Copilot could help me move through implementation tasks, while the tests gave me a repeatable way to check important parts of the result.

LazyDeskOrg Tests:

Copilot Usage Evidence:

Copilot_convo1:

Copilot_convo2:

Summarized notes:

Why Does Open Innovation Matter?

For a tool that handles personal notes, I like the idea that the AI can run on the same computer where the notes are entered.

Because LazyDeskOrg uses a locally running model, its normal workflow doesn't require sending notes to a hosted AI API. That gives users more control over where their data goes and lets them experiment without needing a paid AI API subscription. Local processing isn't a guarantee of complete privacy, of course; users still need to consider their computer, storage, and any services they choose to add.

Open-weight models and open-source tools also make experimentation more accessible. I can inspect the code, change the prompts, test different behaviors, and explore other locally supported models without rebuilding the entire application around a closed service.

For me, open innovation is about being able to understand and change the tools I use - not just being given a result by a black box.

It is a small project, but it shows how accessible AI tools can be combined to solve an everyday problem without adding unnecessary infrastructure.

The Lazy Payoff

The payoff I'm aiming for is fewer minutes spent cleaning up notes and more attention available for the work behind them.

I haven't measured a reliable time saving yet 😂, so I won't pretend that LazyDeskOrg saves a particular number of minutes. What it offers today is a quicker starting point: instead of formatting and grouping everything by hand, you can review an AI-generated draft and decide what to keep.

That is the kind of laziness I like: not avoiding the work that matters, just removing a little of the busywork around it. ✨

Prize Categories

Best Use of GitHub Copilot — I'm entering this category to highlight how I used Copilot Agent during development and paired that work with unit tests and GitHub Actions.

The goal wasn't to let an agent build something and trust it blindly. It was to use AI assistance while keeping the code testable and the results open to inspection.