DEV Community: M.Likhit Naidu

Offer lens

M.Likhit Naidu — Tue, 27 Oct 2026 18:08:47 +0000

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

What I Built

OfferLens — Exposing the Ghost Behind Fake Job Offers 👻

Job scams have evolved. They no longer look like obvious spam messages filled with spelling mistakes. They can look like legitimate internship offers, professional recruiter messages, or exciting opportunities from companies that may not even exist.

For students and early-career developers, one convincing message can be enough to lose money, expose personal information, or fall into a recruitment scam.

OfferLens is an AI-powered job scam detection tool designed to expose the red flags hidden inside seemingly legitimate job offers.

Users can submit job descriptions, recruiter messages, emails, or documents for analysis. OfferLens examines suspicious language, contextual patterns, and potentially dangerous URLs to produce a risk score and actionable recommendations.

The goal is not just to label a message as suspicious. It is to help users understand why it might be dangerous and what they should do next.

The connection to Ghost in the Machine is simple: sometimes, the most dangerous thing is not what a message says on the surface, but what hides beneath it.

OfferLens attempts to make those invisible warning signs visible.

Demo

GitHub Repository: https://github.com/geekyNads/offer-lens
Live Demo: [Add your deployed OfferLens URL here]

Try analyzing a suspicious-looking internship offer and examine the signals behind its risk assessment.

Code

Explore the source code, inspect the implementation, and contribute to the project:

View OfferLens on GitHub

The project brings together machine learning, URL safety checks, and explainable risk scoring to tackle a real-world problem affecting job seekers.

How I Built It

OfferLens combines multiple detection signals rather than relying on a single keyword filter.

The system is designed around three main components:

1. Machine Learning Detection

A fine-tuned DistilBERT model analyzes the contextual meaning of job-related messages to identify patterns associated with fraudulent offers.

This matters because suspicious messages can be professionally written. Contextual classification can detect patterns that basic keyword matching might miss.

2. URL Safety Detection

Extracted URLs can be checked using Google Safe Browsing to identify known unsafe destinations. This adds another layer of scrutiny when a recruiter message directs someone to an unfamiliar website.

3. Suspicious Keyword Analysis

The system examines indicators such as requests for upfront payments, unrealistic compensation, artificial urgency, and attempts to move conversations to unverified channels.

These signals contribute to a combined risk score:

Risk Score = 0.6 × ML + 0.2 × Keywords + 0.2 × URL

The components are weighted to combine contextual machine learning with explicit warning signs and URL safety information.

OfferLens can then present a risk assessment alongside explanations, safety recommendations, a checklist, and a suggested safe reply.

The application uses a React-based frontend and a FastAPI backend for machine learning inference, with Python handling the detection logic.

Importantly, a risk score is a decision-support signal, not proof that a recruiter is fraudulent. Users should still verify employers and job offers independently.

Why Does Open Innovation Matter?

AI-powered security tools should not be black boxes that demand blind trust.

Open innovation makes it possible for developers to inspect the detection logic, understand how different signals contribute to a result, improve the implementation, and experiment with better approaches.

Using an open-weight machine learning model also provides greater control over model deployment and fine-tuning than relying entirely on a closed, hosted AI API.

For a project like OfferLens, that flexibility matters:

Transparency: Developers can examine and improve the detection pipeline.
Experimentation: Models, datasets, and scoring strategies can be evaluated and refined.
Accessibility: Students and independent developers can build practical AI security tools without depending entirely on expensive proprietary inference services.
Community-driven improvement: Contributions can help address false positives, improve detection coverage, and make the system more useful.

Open source does not automatically make an AI system accurate or secure. It makes independent inspection and improvement possible.

That distinction matters when building tools intended to protect people.

The Spirit of It

The most unsettling scams are not necessarily the ones that look suspicious.

They are the ones that look like the opportunity you have been waiting for.

For a student looking for an internship, a message promising a great role can feel like a breakthrough. A request for a small registration fee might seem harmless. A link to an unfamiliar website might look like just another step in the hiring process.

That is where the real problem begins: when the warning signs are present, but the opportunity looks too good to question.

OfferLens is my attempt to bring those hidden signals to the surface before someone makes a costly mistake.

Sometimes, the ghost in the machine is the risk we cannot see until it is too late.

Built by @geekyNads.

VerifyIntern: An Open-Source Internship Scam Checker for Students

M.Likhit Naidu — Tue, 20 Oct 2026 13:32:48 +0000

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

What I Built

Applying for internships should be exciting. Instead, students often have to spend hours wondering whether an offer is legitimate or whether they're about to lose money to a scam.

Fake internship offers, registration-fee demands, impersonated companies, suspicious domains, and fraudulent training programs make it harder for students to trust opportunities they find online.

So I built VerifyIntern — an open-source, community-maintained legitimacy checker for internship and job offers.

Paste an offer message, enter a company name, or check a website or email domain. VerifyIntern looks for documented scam patterns, checks its sourced register of flagged employers, highlights the evidence behind its findings, and links to the public advisories that support them.

Instead of giving students an unexplained verdict, it shows them why something looks suspicious.

The project is designed around a few principles:

Evidence over blind trust: Show the patterns that matched and link to their sources.
Privacy by design: Offer text is checked in the browser and isn't uploaded to a server.
Human-reviewed reports: Community submissions are reviewed against evidence before being added to the register.
Honest uncertainty: No match doesn't mean an offer is guaranteed to be legitimate.

The goal is simple: make checking an opportunity easier than falling for a convincing scam.

Demo

🔗 Live demo: https://geekynads.github.io/verify-intern/

Try pasting a suspicious internship message, checking a company or domain, and examining the evidence behind the result.

Code

💻 GitHub repository: https://github.com/geekyNads/verify-intern

The project is open source under the MIT License for its code, with the dataset licensed separately under CC BY-SA 4.0.

Contributions that improve the detection rules, expand the sourced dataset, strengthen testing, or make the checker more accessible are welcome.

How I Built It

VerifyIntern combines a lightweight browser-based checker with a structured, community-maintained register of documented suspicious employers and scam patterns.

The core implementation includes:

JavaScript: Runs the classifier directly in the browser.
Python: Provides a matching classifier and supports the optional API.
Structured data: Stores sourced employer records in JSONL format.
FastAPI: Exposes optional endpoints for integrations and bulk checks.
Source ingestion and review: Collects candidate records into a pending queue before human approval.
Automated validation and tests: Checks dataset quality and verifies that the Python and JavaScript classifiers behave consistently.
Static deployment: Makes the checker available without requiring a backend for ordinary use.

The project deliberately favors transparent, deterministic checks over an opaque score. Its rules look for signals such as upfront fees, payments to personal accounts, lookalike domains, manufactured urgency, and suspicious requests for academic information.

A note on AI: The current documented implementation is rule-based rather than powered by an integrated open-weight language model. The project is built with open-source technologies, but I don't want to misrepresent that as an AI model running inside the application.

Why Does Open Innovation Matter?

Students shouldn't need a paid subscription to evaluate whether an internship offer deserves their trust.

Open innovation makes VerifyIntern easier to inspect, fork, adapt, and improve. A college placement cell can host its own version, a developer can add new detection rules, and contributors can improve the evidence register without depending on a proprietary service.

It also makes accountability possible. Anyone can inspect how a rule works, examine the data behind a flag, or challenge an entry that lacks sufficient evidence.

The privacy-first design matters, too. Students can check messages locally without sending potentially sensitive offer communications to an external AI provider.

And because the project is community-maintained, improvements don't have to wait for a commercial vendor to prioritize them.

My longer-term goal is to explore how open-weight AI could help explain suspicious messages, identify previously unseen scam patterns, and assist maintainers with evidence review — while keeping source verification and human approval central to the process.

My Agent Session

I haven't included an agent session link in this submission. If I publish a DevRelay session documenting development, testing, or an open-source AI integration, I'll add it here.

The Lazy Payoff 🦥

The idea is to replace a frustrating manual process with a quick first-pass check.

Without VerifyIntern, a student might have to search for a company, inspect its domain, look for public scam advisories, and work out whether a suspicious request resembles a known pattern.

With VerifyIntern, those initial checks are brought together in one place, with the supporting evidence shown alongside the result.

That doesn't replace independent verification or guarantee safety. It gives students a faster starting point and makes the reasoning easier to follow.

Prize Categories

Primary challenge: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady

I'll add any applicable partner-specific categories once I've confirmed that the project meets their requirements.

Built to help students spend less time investigating suspicious offers and more time pursuing legitimate opportunities.

If you've encountered an internship scam pattern that should be documented, or want to help improve the checker, contributions are welcome.

Repository: https://github.com/geekyNads/verify-intern

hacktoberfest #devchallenge #hf26challenge #opensource #cybersecurity #students

Polymarket: Exploring Prediction Markets Through Code

M.Likhit Naidu — Tue, 13 Oct 2026 06:43:50 +0000

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

I built Polymarket, an open-source project exploring how prediction-market data and automated trading strategies can be used to make market analysis more systematic.

Prediction markets move quickly, especially when tracking short-term cryptocurrency price movements. Manually monitoring prices, identifying opportunities, and evaluating potential trades can be time-consuming.

This project is my attempt to explore that problem through code: using APIs, automation, and algorithmic logic to make market analysis more efficient.

The intended audience includes developers experimenting with prediction-market APIs, algorithmic trading enthusiasts, and people interested in building their own market-analysis tools.

The potential side-hustle opportunity is a tool that helps users monitor markets, evaluate strategies, and make more informed decisions. This is an experimental project, not a promise of profitable trades.

Demo

GitHub repository: github.com/geekyNads/Polymarket

The repository is the primary place to explore the implementation and follow the project's development.

Code

Explore the source code, review the implementation, and contribute:

View the Polymarket repository on GitHub

How I Built It

I approached this project with a focus on programmatic market analysis and automation.

My development process involved exploring how prediction-market data can be accessed, processed, and used to evaluate trading opportunities. I also wanted to understand how automated decision-making could fit into a system where prices and conditions change rapidly.

The broader technical direction includes:

Market data: Working with prediction-market data and APIs.

Automation: Reducing the need for repetitive manual monitoring.

Strategy development: Exploring rule-based approaches to identifying potential opportunities.

Open-source development: Keeping the code available for inspection, experimentation, and future improvements.

My goal is to keep learning by building something practical rather than treating algorithmic trading as a purely theoretical exercise.

Why Does Open Innovation Matter?

Open innovation matters because financial automation should not be a black box.

When the implementation is open source, developers can inspect the logic, understand how decisions are made, identify weaknesses, and propose improvements. They can also experiment with alternative strategies without depending entirely on a closed platform.

For projects involving AI and automated trading, this transparency is especially important. A model or algorithm can be wrong, market conditions can change, and backtested results do not guarantee future performance.

Open-source development makes it easier to learn collaboratively, reproduce experiments, and build tools that others can adapt to their own research.

That is the value I want this project to explore: making experimentation accessible and encouraging people to understand the systems they use.

My Agent Session

I don't have a public agent-session recording to share yet.

Prize Categories

Side Hustle — exploring the potential for an open-source market-analysis and automation tool.

Built by @geekyNads.

Disclaimer: This project is experimental and is not financial advice. Automated trading involves risk, and no strategy guarantees profits.