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

Lasya Lingam — Tue, 20 Oct 2026 09:10:07 +0000

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.

CloudBlueprint AI - Hacktoberfest Open-Source AI Challenge: Week 2

Lasya Lingam — Wed, 14 Oct 2026 20:31:09 +0000

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

What I Built

CloudBlueprint AI turns an early-stage project idea into a practical AWS project plan. A user describes the problem, intended users, and desired features, and the app generates a structured plan with a project summary, suggested features, AWS architecture, data flow, security considerations, and build phases.
It’s aimed at indie developers, students, and small teams who want help turning an idea into an initial cloud design. It could save time on early planning and provide a useful starting point before implementation.

Demo

How CloudBlueprint AI works

Code

Meher01 / CloudBlueprint-AI

CloudBlueprint AI - Hacktoberfest Open-Source AI Challenge: Week 2

CloudBlueprint AI turns a project idea into a practical AWS project plan. Enter a project title, the problem it solves, intended users, and any desired features. The app checks that the idea is understandable, then generates a plan with an AWS architecture, data flow, security considerations, and build phases.

The project uses a React and TypeScript frontend, a FastAPI backend, and the Qwen 2.5 3B model running locally through Ollama. Generated plans are suggestions, not production-ready architecture designs.

Features

Generate a structured plan with six sections
- Project summary
- Suggested features
- AWS architecture
- Data flow
- Security and privacy considerations
- Build phases
Reject input that the language model identifies as unintelligible.
Display section headings in bold and list items as bullets.
Download a generated plan as a text file.
Run the language model locally with Ollama.

Technology

Frontend: React, TypeScript, and Vite
Backend…

View on GitHub

How I Built It

CloudBlueprint AI uses Qwen 2.5 3B, an open-weight model run locally with Ollama. The frontend is built with React and TypeScript, and the backend uses Python and FastAPI to send project details to the model and return its generated plan.
The model is central to the product: it interprets each project idea and creates a tailored plan, rather than returning a fixed template. The prompt guides it to use AWS services in the proposed architecture and to explain their roles, tradeoffs, and security considerations.

Why Does Open Innovation Matter?

Open-weight models made it possible to build and experiment with an AI-powered planning tool while running inference locally. That gave me control over which model to use and how it responds, without making the project depend on a closed model API.
It also makes the project easier to adapt: developers can inspect the model options, change the prompts, and run the system in their own environment.

New to DEV

Lasya Lingam — Sun, 04 Oct 2026 08:28:20 +0000

Exploring Hacktoberfest for the first time.

DEV Community: Lasya Lingam

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

What I Built

Demo

Code

Meher01 / LazyDesk

LazyDesk - Hacktoberfest Week 3 Dev Challenge

Features

Requirements

Installation

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

CloudBlueprint AI - Hacktoberfest Open-Source AI Challenge: Week 2

What I Built

Demo

Code

Meher01 / CloudBlueprint-AI

CloudBlueprint AI - Hacktoberfest Open-Source AI Challenge: Week 2

Features

Technology

How I Built It

Why Does Open Innovation Matter?

New to DEV