DEV Community: Deshan Nethmina

N-CODE GhostLog AI: Turning Forgotten Logs into Halloween Stories with Gemma

Deshan Nethmina — Wed, 28 Oct 2026 10:23:28 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

I built N-CODE GhostLog AI, a local Halloween storytelling application powered by Gemma 3 1B through Ollama.

The idea is simple: what if an old computer's forgotten logs could tell a ghost story?

Users enter fictional terminal logs, choose an unsettling, melancholic, or playful mood, and decode a transmission. Gemma generates a title, a 110–190 word story, three clues, and a haunting final line. Users can download the result as Markdown.

The sample includes an archived session resuming after 13 years, a user called nobody_here, and a notification saying, “you forgot the light.”

These are creative prompts. GhostLog does not execute commands, scan a computer, or diagnose security incidents.

Demo

Open the recorded browser walkthrough · Direct video download.

The recording shows the real application calling local Gemma. The same browser test verifies the Markdown export and captures the mobile layout.

Verified GitHub Actions run · Evidence and reproduction notes

This is a local application, rather than a publicly hosted AI service. Judges can reproduce it with Python 3.10+ and Ollama:

git clone https://github.com/Deshan217/ncode-ghostlog-ai-hf26.git
cd ncode-ghostlog-ai-hf26
ollama pull gemma3:1b
# Start ollama serve separately if Ollama is not already running.
python server.py

Then open http://127.0.0.1:8766. No app account or API key is required. Model downloads need internet access; generation uses the local Ollama endpoint.

Code

Source repository · Verified application commit

The application code is MIT licensed. Gemma's weights have their own terms.

How I Built It

The application uses Python's standard library for the local HTTP server and HTML, CSS, and JavaScript for the interface. It needs no pip or npm packages to run. Node, Playwright, and Chrome are used by CI to record the demo.

The data flows from the browser to /api/haunt, through input validation, into Ollama's local /api/generate endpoint. Gemma produces JSON, the server validates it, and the interface renders the fields as text.

A green test was not enough

The earlier workflow completed real inference, but its saved API result contained only “A descent into a forgotten memory.” That passed because the test checked only for a nonempty story and three clues.

It proved the model ran. It did not prove the storytelling requirement worked.

I strengthened the integration to pass an explicit JSON schema, require 110–190 story words, reject malformed or unfinished responses, and allow one validation retry. If both outputs fail, the app reports an error instead of inserting a canned story.

The updated verification checks the raw model response against the application output. The browser test independently generates a story, verifies the rendered narrative matches the API response, and checks the downloaded Markdown.

Verified results on October 28, 2026: 19 automated tests passed; actual API generation produced 149 story words and browser generation produced 155 words. Both used gemma3:1b and returned three clues. The evidence records the source commit, Ollama version, model digest, and raw generated text.

One stricter CI run returned an error; the subsequent evidence run passed with the same generation code. These are successful examples, not a measured reliability rate. Word counts and JSON checks also do not establish whether every story is creative or every clue is well grounded.

Why Does Open Innovation Matter?

Gemma is the part that turns the fictional clues into a new narrative. Without the model, this application would be an input form with no story engine.

Running the open-weight model through Ollama means the text-generation request goes to the user's machine rather than a proprietary hosted language-model API. The prompt and validation code are available to inspect and change.

That makes the experiment easier to reproduce and adapt. It also keeps the project independent of a paid text-generation API.

GhostLog does not save input history. I still recommend fictional or fully redacted logs: local processing is not a reason to paste credentials or personal information. I have not measured performance across different hardware or formally tested an offline installation.

Prize Categories

Best Use of Gemma — Gemma 3 1B generates the narrative, clues, title, and final line through the application's actual inference path.

What's Next?

I would test more inputs and moods, evaluate how consistently clues connect to the supplied logs, and improve the experience on slower computers.

Built by N-CODE STUDIO for Hacktoberfest 2026.

AI assistance was used for implementation, debugging, verification, and drafting this write-up.

References: Ollama structured-output documentation. Two useful community discussions were Ollama Structured Outputs in Practice — Getting Type-Safe JSON from Local LLMs with Pydantic by @jangwook_kim_e31e7291ad98 and Structured Output Gives You Syntax. It Doesn't Give You Semantics by @aiexplore369zoho.

N-CODE LazyFlow AI: Making Everyday Tasks Easier with Open-Weight Gemma

Deshan Nethmina — Tue, 20 Oct 2026 12:56:22 +0000

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

What I Built

I built N-CODE LazyFlow AI, an open-source productivity assistant powered by Google's open-weight Gemma 3 model and Ollama.

LazyFlow helps people turn overwhelming to-do lists into manageable daily plans.

Instead of manually organizing tasks, users can enter their tasks, select their energy level, and choose how much time they have available.

The AI then generates prioritized activities, realistic time allocations, a small first step, and suggestions for tasks that can wait.

The goal is to reduce the effort of planning and make everyday work feel more manageable.

Demo

View verified AI demo and download recording

GitHub Repository:

https://github.com/Deshan217/ncode-lazyflow-ai-hf26

Verified Real Gemma AI Test:

https://github.com/Deshan217/ncode-lazyflow-ai-hf26/actions/runs/39414746192

Real AI Output Artifact:

https://github.com/Deshan217/ncode-lazyflow-ai-hf26/actions/runs/39414746192/artifacts/12260269969

This proof of concept runs locally using Ollama and Gemma 3. The linked GitHub Actions workflow successfully executed the real model through the application API.

The application is designed for local execution rather than a publicly hosted AI service.

Code

The complete project is open source under the MIT License.

Source Code:

https://github.com/Deshan217/ncode-lazyflow-ai-hf26

The repository includes the application, responsive dashboard, local AI integration, automated tests, and GitHub Actions verification.

How I Built It

I used a simple, lightweight stack:

Python standard library for the local HTTP server.
HTML, CSS, and JavaScript for the responsive dashboard.
Ollama for local AI inference.
Gemma 3 1B as the open-weight language model.
GitHub Actions for automated testing and real AI verification.

How It Works

The user enters an unorganized task list.
The user selects an energy level and available time.
The Python server validates the input.
The application sends a structured prompt to Gemma through Ollama.
Gemma generates a JSON-based action plan.
The application validates the response and adjusts time allocations to fit the selected budget.
The user receives a daily plan and can export it as Markdown.

Real AI Verification

On October 20, 2026, GitHub Actions successfully executed Gemma 3 1B through Ollama.

The workflow started the local application, submitted a planning request to its API, and verified that a nonempty AI-generated plan was returned.

Automated unit tests and syntax checks also passed.

The evidence is publicly accessible through the repository's GitHub Actions history.

Why Does Open Innovation Matter?

Open-weight AI allows developers to build useful applications with more control over inference and deployment.

Using Gemma through Ollama enables local AI processing without requiring a proprietary cloud language-model API.

For LazyFlow, this means users can keep their task lists on their own machines while still benefiting from AI-assisted organization.

The project also demonstrates how open-source tools can lower the technical barrier to experimenting with useful AI workflows.

The Slow and Steady Approach

LazyFlow focuses on manageable progress rather than unrealistic productivity goals.

It encourages users to start with a small action, prioritize achievable tasks, and work within their actual available time.

The project's effectiveness in saving time has not yet been measured through formal user testing.

Challenges and Lessons

One challenge was ensuring that the AI returned useful structured data rather than free-form text.

I addressed this by using structured JSON generation and validating the model's output before presenting it in the application.

Another challenge was verifying real open-weight AI inference rather than relying exclusively on mocked test data.

GitHub Actions provided a repeatable way to install Ollama, run Gemma, and capture genuine model output.

What's Next?

Future improvements include accessibility enhancements, optional local task history, better plan editing, and feedback from real users.

My aim is to continue improving LazyFlow as a practical, privacy-conscious productivity tool.

Built by N-CODE STUDIO for Hacktoberfest 2026.

N-CODE AI Studio: Turning Website Audits into a Side Hustle with Open-Weight AI

Deshan Nethmina — Fri, 16 Oct 2026 04:59:05 +0000

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

What I Built

I built N-CODE AI Studio, an open-source AI-powered website auditing platform designed to help freelancers, small businesses, and web development agencies understand website performance and identify opportunities for improvement.

Many small business owners struggle to understand technical reports or know which website problems to fix first.

N-CODE AI Studio aims to turn technical website measurements into clear, actionable recommendations using open-weight AI.

The side hustle idea: Freelancers can use this tool to prepare website health assessments and offer professional performance optimization, accessibility improvements, SEO consulting, and website redesign services.

The product is an early-stage prototype. This business concept has not yet been validated with paying customers.

Demo

Application: https://ncode-ai-studio-hf26.vercel.app/

Case Study: https://ncode-ai-studio-hf26.vercel.app/case-study

Verified Lighthouse + Gemma AI Execution:

https://github.com/Deshan217/ncode-ai-studio-hf26/actions/runs/38784847640

Raw Test Evidence:

https://github.com/Deshan217/ncode-ai-studio-hf26/actions/runs/38784847640/artifacts/11998425425

The verified demonstration runs Lighthouse in a GitHub Actions environment and generates recommendations using Gemma 3 through Ollama.

The hosted Vercel application currently demonstrates the interface and case study. Live cloud AI inference and production PageSpeed API quota configuration remain separate deployment improvements.

Code

The project is publicly available on GitHub under the MIT License.

GitHub Repository:

https://github.com/Deshan217/ncode-ai-studio-hf26

The repository contains the Next.js application, audit processing logic, Ollama integration, test workflows, documentation, and reproducible AI testing configuration.

How I Built It

I used the following technologies:

Next.js and React: Application interface and server-side API routes.
TypeScript: Typed application and auditing logic.
Lighthouse: Website performance, accessibility, SEO, and best-practice analysis.
Ollama: Local inference infrastructure.
Gemma 3 1B: Open-weight AI model used for verified recommendations.
GitHub Actions: Automated builds, testing, and reproducible AI execution.
Vercel: Hosting for the application interface.

How the AI Workflow Works

The application is designed to accept a public HTTPS website URL, collect audit findings, and generate an understandable improvement report.

For the verified demonstration, GitHub Actions runs Lighthouse directly in headless Chrome, extracts website audit findings, and provides those findings to a locally running Gemma model through Ollama.

The AI then generates prioritized recommendations that a developer or website consultant can review.

Real Testing Results

I tested the workflow against the N-CODE STUDIO website:

Website: https://ncodest.com/

The October 15, 2026 Lighthouse run produced the following mobile lab scores:

Category	Score
Performance	57/100
Accessibility	78/100
SEO	100/100
Best Practices	100/100

The Gemma model successfully generated recommendations related to accessibility, semantic structure, accessible labels, contrast, and performance optimization.

These results come from a single lab run and should not be interpreted as ongoing measurements or a guarantee of user experience. AI-generated recommendations require human review.

Challenges I Faced

One challenge was Google PageSpeed Insights API quota limits.

Although local Gemma inference worked, the first end-to-end attempt could not retrieve audit data because the PageSpeed API quota had been exceeded.

To produce reproducible evidence, I implemented a separate GitHub Actions workflow using Lighthouse directly with headless Chrome, without depending on the PageSpeed API.

This workflow successfully completed both a real Lighthouse audit and real open-weight AI inference.

Another challenge is hosting: an Ollama instance running locally is not automatically accessible to a cloud-hosted Next.js application. A secure production AI service is part of the future roadmap.

Why Does Open Innovation Matter?

Open innovation gives independent developers the freedom to experiment, learn, customize, and build useful products without depending entirely on proprietary AI platforms.

Using Gemma through Ollama makes it possible to run the language model under developer control.

For N-CODE AI Studio, this provides several advantages:

Ability to inspect and modify the AI prompt and integration.
Flexibility to experiment with different open-weight models.
Potential to operate local inference without per-request proprietary model API charges.
Opportunities for community contributions and improvements.
Greater control over where AI processing takes place.

The complete application is shared under the MIT License.

My goal is to make useful AI-assisted website consulting more accessible to independent developers and smaller businesses.

What's Next?

My future plans for N-CODE AI Studio include a securely hosted AI inference service, better audit reporting, user authentication, rate limiting, audit history, and professional client-ready reports.

I also want to collect feedback from freelancers and small business owners to see whether this tool can become a practical, affordable website consulting product.

Built by N-CODE STUDIO for Hacktoberfest 2026.

Thank you to the open-source community and the developers building accessible AI tools!

Prize Categories

Best Use of Gemma

N-CODE AI Studio uses Google's open-weight Gemma 3 1B model through Ollama to transform real Lighthouse audit measurements into actionable website improvement recommendations.

The model was successfully executed and tested using GitHub Actions, with real inference results and supporting evidence available in the public repository.

N-CODE AI Studio: An Open-Weight AI Website Audit Side Hustle

Deshan Nethmina — Fri, 16 Oct 2026 04:52:02 +0000

Hacktoberfest 2026 — Week 2: Side Hustle

What I Built

I built N-CODE AI Studio, an MIT-licensed website auditing prototype for freelancers and small-business owners. It combines measurable Lighthouse findings with actionable advice generated by an open-weight AI model. The side-hustle idea: a freelancer can offer a transparent introductory website health check, then optionally offer human-led accessibility, SEO, and performance improvements. I have not validated any revenue or customer demand.

Demo

Public case-study demo (verified CI results): https://ncode-ai-studio-hf26.vercel.app/case-study
App: https://ncode-ai-studio-hf26.vercel.app/
Source: https://github.com/Deshan217/ncode-ai-studio-hf26
Real AI + Lighthouse CI run: https://github.com/Deshan217/ncode-ai-studio-hf26/actions/runs/38784847640
Downloadable raw evidence: https://github.com/Deshan217/ncode-ai-studio-hf26/actions/runs/38784847640/artifacts/11998425425

Before publishing: verify the deployed /case-study route responds publicly after the latest Vercel deployment. The original live audit endpoint may still hit Google PageSpeed API quota; cloud Gemma inference is not yet working on Vercel. The working proof is the GitHub Actions run.

How I Built It

The interface is built with Next.js, TypeScript and React. The web-app audit route reads Google PageSpeed Insights Lighthouse lab metrics. The open-weight AI integration uses Ollama and Gemma 3.

To produce reproducible test evidence independent of the PageSpeed API quota, I also developed a GitHub Actions workflow that installs Ollama, pulls gemma3:1b, runs headless Chrome/Lighthouse directly against https://ncodest.com/, and feeds the audit metrics to a locally hosted Gemma instance. This is a real execution, not generated sample data.

The successful October 15, 2026 GitHub Actions run (#38784847640) recorded these single-run mobile Lighthouse lab scores:

Category	Score
Performance	57
Accessibility	78
SEO	100
Best Practices	100

Gemma returned nonempty practical recommendations including review of accessible names, ARIA and page structure, contrast and labeling, and JavaScript/main-thread performance. These are model-generated recommendations to be validated by a developer, not proof of specific fixes. The model also suggested ungrounded pricing; I excluded that from this evidence-based summary.

The complete real Lighthouse JSON and model response are available as the GitHub Actions artifact. GitHub CI installation, automated tests, typecheck and production build also passed in successful runs.

Why Open Innovation?

Running an open-weight Gemma model in Ollama makes the AI recommendation layer inspectable, locally runnable and configurable. Developers can see the prompt logic and run their own tests without relying on a proprietary chat API. The code is shared under the MIT license. This is not a completely offline product: the default web-app measurement layer currently uses Google PageSpeed Insights, while the CI proof uses local Lighthouse CLI.

The Side Hustle

The initial service concept is a website audit report that a small agency or freelancer could produce for a local business, with optional improvements done by a human specialist. The aim is to lower the cost of the first diagnosis, not to replace web developers or falsely promise business outcomes.

Challenges and Lessons

Unauthenticated Google PageSpeed Insights quotas caused the initial combined test to fail, even while real Gemma inference passed. I addressed the CI demonstration by running Chrome/Lighthouse locally.
An app deployed on Vercel cannot automatically reach Ollama running on my laptop. Hosted AI requires a separately secured inference service; the current Vercel app is not presented as fully working with AI.
Lab results vary; one mobile Lighthouse run is not equivalent to actual Core Web Vitals field experience.
LLM recommendations can contain questionable details, so manual review matters.

What's Next?

Host the AI model behind a secure, authenticated inference endpoint, configure production audit quotas or use a controlled Lighthouse worker, improve abuse prevention and rate limits, collect real user feedback, and develop client-ready branded PDF reporting.

Challenge tags: devchallenge, hf26challenge (confirm these in the DEV challenge editor).

Author checklist before pressing Publish: verify public case-study URL, add a genuine screenshot or short screencast if required by the official template, check eligibility, ensure all required sections/tags are included, and confirm submission deadline. This text is a draft; publication has not occurred.