DEV Community: Hannan Naveed

Building SynthClaw: Agent Society for the Qwen Cloud Hackathon

Hannan Naveed — Sun, 12 Jul 2026 17:14:25 +0000

The Journey building project with Alibaba cloud and Qwen Cloud AI models

Hackathons usually start with an idea.

Mine started with a question.

Why are AI agents still working alone?

Most modern coding agents have become incredibly capable, but they often rely on a single model trying to plan, reason, execute, and review everything by itself. Humans don't work that way. Teams do.

That thought eventually became SynthClaw: Agent Society.

The goal wasn't to build another chatbot or another AI coding assistant. I wanted to build something that behaves more like an engineering team—a collection of specialized agents that collaborate, delegate work, review each other's outputs, and solve larger problems together.

Since the project is open source, another goal was keeping it lightweight. I wanted developers to be able to run it locally while still supporting modern capabilities like MCP, multiple LLM providers, community skills, shell execution, and extensibility.

One of the most interesting parts was designing the terminal experience. Instead of showing endless logs, I wanted the CLI to feel alive. Watching agents spawn, complete work, and coordinate in real time made the project feel much closer to operating a real AI organization than chatting with a single assistant.

For this hackathon I also integrated Qwen into the provider system and deployed the backend on Alibaba Cloud. The deployment itself wasn't the difficult part—it was navigating account setup and verification—but once everything was working, having the project running in the cloud completed the overall architecture.

One thing I learned while building this project is that better AI isn't only about larger models. System design matters just as much. Planning, delegation, communication, memory, and verification often improve reliability more than simply switching models.

This hackathon pushed me to think less about individual prompts and more about how intelligent systems should cooperate.

There's still a long roadmap ahead for SynthClaw. I want to expand the Agent Society concept with dynamic role creation, richer collaboration, distributed execution, visual dashboards, and a growing ecosystem of community-built skills.

Hopefully this is just the beginning.

Thanks to the Alibaba Cloud and Qwen teams for organizing the hackathon and giving developers a reason to experiment with new ideas rather than just build another chatbot.

Happy hacking 🚀

I request everyone who see this. Plz review and give a feedback to this project

Hannan Naveed — Fri, 10 Jul 2026 14:00:00 +0000

DEV Weekend Challenge: Passion Edition Submission

Hannan Naveed

Jul 10

Scotium: A Github Powers platform with 34 tools built-in, Discovery Engine and much more...

#devchallenge #weekendchallenge

6 min read

Scotium: A Github Powers platform with 34 tools built-in, Discovery Engine and much more...

Hannan Naveed — Fri, 10 Jul 2026 13:59:19 +0000

This is a submission for Weekend Challenge: Passion Edition

Scotium: GitHub Power-User Platform — 34 Analysis Tools, Discovery Engine, and Code Editor

I built a GitHub intelligence platform with 34 analysis tools, a discovery engine, code editor, and README component generator—all without leaving one dashboard.

Powered by Google AI

Scotium - Discover Trending GitHub Repos

Find trending open source projects and repositories on GitHub.

scotium.pages.dev

What I Built

Scotium is a comprehensive GitHub intelligence platform that transforms raw GitHub data into actionable insights. Here's what's included:

34 Built-in Analysis Tools:

Repository Analysis (12 tools): Health Score, Stars, Last Commit, PR Merge Speed, Issue Health, Bus Factor, Releases, Fork Activity, License, Repo Size, Tech Stack, Dependencies
Profile Insights (8 tools): Total Stars, Total Forks, Follower Ratio, Account Age, Repositories, Organizations, Top Repo, Top Languages
Discovery + Dashboard (10 tools): Rising Stars, Undiscovered Gems, Most Forked, Active Giants, Repo Health Table, Stale Repos Alert, Open PR Tracker, Star Leaders, Repo vs Repo comparison, User vs User comparison

Core Features:

🔍 Discovery Engine — Find Rising Stars (new repos gaining traction), Undiscovered Gems (active but low-star repos), Most Forked projects, and recently active popular repos
⚖️ Comparison Tool — Side-by-side analysis of repositories or users with visual progress bars showing wins on stars, forks, contributors, and more
✏️ Code Editor — Browse any repository's files, edit code with syntax highlighting, create branches, commit changes, and open Pull Requests—all without leaving Scotium
🧩 README Components — 30 ready-to-copy components for your GitHub README (stats cards, streak counters, trophies, activity graphs, badges)
📊 Dashboard — Personal GitHub command center with all your repos (including private), stale repo tracking, open PR monitoring, and star rankings
🔎 Smart Search — Cmd+K search modal with live results as you type

The entire platform is a client-side React SPA that communicates directly with GitHub's REST API—no backend infrastructure required.

Demo

Live Site: https://scotium.pages.dev

Try it out:

Discover repos → Visit https://scotium.pages.dev/explore and filter by language or time range
Analyze any repo → Go to any repo detail page (e.g., https://scotium.pages.dev/facebook/react) and see 12 analysis tools
Compare projects → Visit https://scotium.pages.dev/compare to compare two repos or developers side-by-side
Generate README badges → Check https://scotium.pages.dev/components and copy any of 30 components to your profile
Edit code → Click the editor icon on any repo to browse files, edit code, create branches, and open PRs
Track your projects → Sign in with GitHub to access https://scotium.pages.dev/dashboard for personal repo stats and alerts

Code

GitHub Repository: github.com/truehannan/scotium-dev

Tech Stack:

React 18 + Vite 5 — Component-based UI with lightning-fast builds
Tailwind CSS + Framer Motion — Utility-first styling with smooth animations
CodeMirror — Syntax-highlighted code editor
TanStack Query — Efficient data fetching and caching
React Router — Client-side routing
GitHub REST API — All data fetching
Cloudflare Pages — Serverless hosting with zero config
Cloudflare D1 — SQLite caching layer for performance

Project Structure:

scotium/
├── src/
│   ├── components/        # React components (analysis cards, dashboard, editor)
│   ├── pages/            # Route pages (/, /explore, /compare, /dashboard, etc.)
│   ├── lib/              # Utilities (GitHub API, analysis logic, formatting)
│   ├── hooks/            # Custom React hooks (useQuery, useGitHub, etc.)
│   └── App.jsx           # Main app routing
├── vite.config.js        # Vite build config
├── tailwind.config.js    # Tailwind theming
└── wrangler.toml         # Cloudflare Pages config

Key Implementation Details:

GitHub OAuth Integration: No password database—pure GitHub OAuth for private repo access and authenticated code edits
Analysis Algorithms:
- Health Score = composite of commit frequency, PR merge time, issue health, and dependency freshness
- Bus Factor = core contributor count from commit history
- PR Merge Speed = median time from open → merge across all PRs
- Tech Stack = parsed from package.json, requirements.txt, go.mod, etc.
Performance: TanStack Query caches all API responses; D1 stores analysis results to reduce GitHub API calls
Rate Limiting: Handles GitHub's 5K request/hour free tier limit gracefully

All code is open source. Star on GitHub if you find it useful!

How I Built It

Planning & Research (Days 1-2)

I started by analyzing what GitHub doesn't surface natively. While GitHub shows basic repo stats, it doesn't answer questions like:

"Is this project healthy or abandoned?"
"How long do PRs actually stay open?"
"What's the real contributor bus factor?"
"Are there undiscovered gems in my language that are actually active?"

I researched competing platforms (GitStar, OSSInsight, Trendshift) to understand what matters, then designed 34 metrics across three categories.

Architecture & Setup (Days 3-4)

Scaffolded React 18 + Vite 5 for fast iteration
Integrated GitHub OAuth for private repo access
Set up TanStack Query for efficient data fetching with built-in caching
Configured Cloudflare Pages + D1 for serverless hosting and SQLite caching
Designed reusable component system for analysis tools

Repository Analysis Tools (Days 5-7)

Built 12 tools that analyze any public or private GitHub repository:

Core metrics:

Health Score — Composite score (1-10) based on commit frequency, PR merge speed, issue resolution rate, and dependency freshness
Bus Factor — Number of core contributors; how vulnerable is the project if one person leaves?
PR Merge Speed — Median time from PR open to merge; signals maintainer responsiveness
Issue Health — Ratio of resolved to open issues; are maintainers keeping up?
Tech Stack Detection — Automatically parse package.json, requirements.txt, go.mod, Cargo.toml, etc.
Fork Activity — Are forks actually being maintained or abandoned?
Release Tracking — How often are stable versions released?
License Detection — What's the legal status of this project?

Plus: Stars, Last Commit, Repo Size, Dependencies.

Profile Insights (Days 8-9)

Built 8 tools for understanding any GitHub developer:

Total Stars + Forks aggregated across all their repos
Follower Ratio (real influence metric)
Account Age and activity level
Top Repo and Top Languages they use
Organization memberships

Discovery Engine (Days 10-11)

Implemented four discovery modes:

Rising Stars — Repos gaining traction (new but with momentum)
Undiscovered Gems — Active repos with surprisingly few stars (hidden treasures)
Most Forked — Projects people are actually building on top of
Active Giants — Popular repos that are still actively maintained

Each mode sorts GitHub's 100M+ repos by different signals to surface what matters.

Dashboard & Comparison (Day 12)

Personal Dashboard — GitHub OAuth sign-in shows your repos, stale repos (no commits in 30+ days), open PRs, and star rankings
Comparison Tool — Side-by-side comparison of two repos or two users; visual progress bars show who wins on each metric

Code Editor & Components (Day 13)

Built-in Code Editor — Browse any repo's file tree, edit code with syntax highlighting via CodeMirror, create branches, commit changes, and open PRs—all without leaving Scotium
README Components — 30 pre-built copyable components (stats cards, streak counters, trophies, activity graphs, badges) so devs can instantly level up their profile READMEs

Search & Optimization (Day 14)

Cmd+K search modal for instant repo/user lookup
Performance optimization via aggressive query caching and D1 SQLite caching
Mobile responsiveness refinement
Framer Motion animations for polish

Deployment

Deployed to Cloudflare Pages (zero-config, auto-deploy from Git). D1 caching layer reduces GitHub API calls to stay well within the free tier limits.

Why Scotium Matters

GitHub is the home of the open-source universe, but its native tools don't answer the questions developers actually ask:

"Is this project actually maintained or a ghost town?" → Health Score tells you instantly
"How long will my PR sit here?" → PR Merge Speed shows the real tempo
"Are there cool projects in my stack that nobody knows about?" → Undiscovered Gems surfaces them
"Can I trust this codebase?" → Bus Factor reveals hidden dependency on key people
"What's the real engagement with this project?" → 12 analysis tools give you the full picture

Scotium fills that gap. It's built for power users, indie developers, and anyone who wants to make smarter decisions about which projects to contribute to, learn from, or depend on.

Stats

34 analysis tools across 3 categories
10 pages covering discovery, analysis, comparison, editing, and components
100% client-side — No backend infrastructure needed
GitHub API-native — Direct integration with GitHub's REST API
Free to use — No sign-up required for public data; GitHub OAuth for private repos

Try It Now

Website: https://scotium.pages.dev

GitHub: github.com/truehannan/scotium-dev

Built by: Hannan

Why Every AI Agent Eventually Becomes an Operating System

Hannan Naveed — Thu, 09 Jul 2026 19:36:24 +0000

Every AI Agent Eventually Becomes an Operating System

When I first started building AI agents, I thought the hard part would be making the model intelligent.

I was wrong.

The intelligence was the easiest part.

The real challenge appeared the moment the agent needed to do something.

It Always Starts Simple

Almost every AI project begins with something like this:

User
   │
   ▼
LLM
   │
   ▼
Response

It works.

Until the first real request arrives.

"Deploy this application."

The model can explain how.

It can't actually do it.

So you add tool calling.

Then You Add More

One feature becomes two.

Then five.

Then twenty.

Eventually your architecture starts looking more like this:

Tool calling
File system access
Terminal execution
Memory
Multi-agent workflows
API integrations
Plugin systems
Skills
Scheduling
Background tasks
Context management

At first these feel like unrelated features.

But they're not.

They're all trying to solve the same problem.

Turn reasoning into action.

The Shift Happens Quietly

One day you realize your project isn't really a chatbot anymore.

It's coordinating components.

One part plans.

Another remembers.

Another executes.

Another verifies.

Another communicates with external services.

The language model becomes only one component inside a much larger system.

That's when the architecture changes completely.

You're No Longer Building Around the Model

Many people design systems like this:

Everything
     │
     ▼
    LLM

Eventually it becomes difficult to maintain.

Instead, I started thinking of the model as one participant inside an execution pipeline.

Request
   │
   ▼
Planner
   │
   ▼
Capabilities
   │
   ▼
Execution
   │
   ▼
Verification
   │
   ▼
Response

The language model still makes decisions.

It just isn't responsible for everything anymore.

Integrations Aren't Features

One lesson surprised me.

Adding another integration rarely makes an agent significantly more capable.

Adding better architecture does.

For example, an agent might support:

Direct APIs
MCP servers
Local tools
Code execution
Shell execution

Those are all different ways of reaching the outside world.

The important question isn't:

"How many integrations do we support?"

It's:

"How does the agent decide which capability is appropriate?"

That becomes an architecture problem rather than an integration problem.

Context Is More Important Than Capability

A powerful tool that is never selected is effectively useless.

A lightweight tool chosen at the right time often produces better results.

This completely changed how I think about AI systems.

Instead of adding more features, I spend more time improving:

planning
decision making
capability discovery
execution flow
feedback loops

The result is usually a smarter system without changing the model itself.

AI Agents Are Slowly Becoming Operating Environments

Traditional software waits for instructions.

Modern AI systems coordinate them.

They're managing tools, memory, workflows, external services, files, and multiple execution paths simultaneously.

That feels much closer to an operating environment than a chatbot.

The language model is becoming the interface—not the entire application.

Final Thoughts

Every AI project seems to follow the same path.

You start with prompts.

Then tools.

Then memory.

Then workflows.

Then multiple agents.

Eventually you stop asking:

"How can I make the model smarter?"

And start asking:

"How can I build a better system around it?"

That mindset shift has probably influenced my projects more than any new model release over the past year.

I'm curious whether others building AI agents have noticed the same pattern, or if you've taken a completely different architectural approach.

I made a cloudflare dependent AI Agent

Hannan Naveed — Mon, 04 May 2026 18:22:19 +0000

I made an AI agent which:

Runs online for Free.
Can be accessed via telegram.
Doesn't need an API key of AI.
AI usage is free for almost all generations
Almost unlimited number of automations!

Yes you heard right ✅️

The actual description:

Cloudflare is the only platform which provides almost every service for free with a big number of limitations even for commercial use.

So what I did is to build a plug and play AI Agent which host on workers and by using the cloudflare credentials, it can use almost every service given access too by just using a phone!

It's called Cloudbrain

Try it out:

Cloudbrain

Idk how to get visibility of dev to

Hannan Naveed — Mon, 04 May 2026 06:40:53 +0000

Hannan Naveed

May 4

I made openclaw alternative in python

#agents #ai #opensource #cli

1 min read

I made openclaw alternative in python

Hannan Naveed — Mon, 04 May 2026 01:08:08 +0000

I made my first open source project which is openclaw alternative in Python.

It's called Synthclaw Coagent.

It can easily run on a small VPS or instance of 512 MB RAM.

I used it to automate blog writing and posting on my portfolio with images from unsplash API. I'm planning more.

It works by creating custom programs in python. It has also multi agent feature with many skills.

You can communicate with it by integrating channels like telegram and whatsapp.

As this is my first open source project, maybe there are mistakes or I think definetely.

So all I want is github stars and contributions on my first open source project. I know this may mot be that difficult or it maybe an easy task to do but still I gave my full potential!

DEV Community: Hannan Naveed

Building SynthClaw: Agent Society for the Qwen Cloud Hackathon

The Journey building project with Alibaba cloud and Qwen Cloud AI models

I request everyone who see this. Plz review and give a feedback to this project

Scotium: A Github Powers platform with 34 tools built-in, Discovery Engine and much more...

Scotium: A Github Powers platform with 34 tools built-in, Discovery Engine and much more...

Scotium: GitHub Power-User Platform — 34 Analysis Tools, Discovery Engine, and Code Editor

Scotium - Discover Trending GitHub Repos

What I Built

Demo

Code

How I Built It

Planning & Research (Days 1-2)

Architecture & Setup (Days 3-4)

Repository Analysis Tools (Days 5-7)

Profile Insights (Days 8-9)

Discovery Engine (Days 10-11)

Dashboard & Comparison (Day 12)

Code Editor & Components (Day 13)

Search & Optimization (Day 14)

Deployment

Why Scotium Matters

Stats

Try It Now

Why Every AI Agent Eventually Becomes an Operating System

Every AI Agent Eventually Becomes an Operating System

It Always Starts Simple

Then You Add More

The Shift Happens Quietly

You're No Longer Building Around the Model

Integrations Aren't Features

Context Is More Important Than Capability

AI Agents Are Slowly Becoming Operating Environments

Final Thoughts

I made a cloudflare dependent AI Agent

The actual description:

Try it out:

Idk how to get visibility of dev to

I made openclaw alternative in python

I made openclaw alternative in python

Here are links:-