DEV Community: Muhammad Umer Farooq

How I Built a Full-Stack Quality Skill for AI Coding Agents

Muhammad Umer Farooq — Tue, 21 Jul 2026 09:49:51 +0000

How I Built a Full-Stack Quality Skill for AI Coding Agents

AI coding agents are getting very good at writing code.

But I kept running into the same problem:

They can move fast, but without strong project rules they can also create messy architecture, duplicate utilities, inconsistent APIs, weak security checks, and frontend components that slowly drift away from the design system.

So I built Full-Stack Quality Skill.

It is a reusable AI coding skill for full-stack audits, architecture guidance, long-term project memory, and CI quality gates.

Repo: https://github.com/lablnet/full-stack-quality-skill

Website: https://skills.lablnet.com

Why I Built It

When I use AI agents like Cursor, Codex, Claude Code, Antigravity, or similar tools, I do not only want them to "write code".

I want them to think like a careful senior engineer:

Is the database normalized correctly?
Are backend layers clean?
Is business logic leaking into controllers?
Are frontend components consistent?
Are Vue components using composables?
Are React components using hooks correctly?
Are HTTP methods and status codes right?
Is GraphQL safe from N+1 problems?
Are security and privacy risks checked?
Are tests missing for critical paths?
Is documentation still matching the code?

That is a lot to remember every time.

So instead of repeating the same instructions in prompts, I turned them into a reusable skill.

What It Covers

The skill includes audit areas for:

Database
Backend
Frontend
Mobile
HTTP APIs
GraphQL
Security
Privacy
Accessibility
i18n
Analytics
Background jobs
Infrastructure
Testing
Performance
Observability
Delivery / CI
Multi-tenancy
Payments
Notifications
Data import/export
API compatibility
Developer experience
AI/LLM safety

It also includes examples for common stacks:

Node.js / TypeScript
Python
Django
Laravel
Java / Spring
C# / ASP.NET Core
Go
Ruby on Rails
React
Next.js
Vue
Angular
SvelteKit
Flutter
React Native
Kotlin / Android
Swift / iOS
SQL
GraphQL

Read-Only Audits by Default

One important rule:

Audit mode is read-only.

That means the agent should not edit source code, schemas, configs, docs, generated files, or lockfiles unless I explicitly ask it to.

This matters because sometimes I want an honest review before touching anything.

For a small audit, it can produce:

review.md
findings.json

For a broader audit, it can produce per-area files:

review.md
findings/
  backend.findings.json
  frontend.findings.json
  security.findings.json
  database.findings.json

Markdown is for humans.

JSON is for structured audit output.

Parallel Auditors

One thing I really wanted was parallel review.

For a whole-project audit, the skill tells the agent to run separate read-only auditors in parallel:

database auditor
backend auditor
frontend auditor
security auditor
testing auditor
performance auditor
delivery auditor

If the project does not use GraphQL, the GraphQL auditor is skipped.

This makes the review much cleaner than one huge generic pass.

Each auditor focuses on one area and returns evidence-backed findings.

Project Memory

The skill also has an optional project context mode.

That means it can help generate long-term project docs such as:

docs/
  agents.md
  architecture.md
  decisions.md
  security.md
  testing.md
  migration-backlog.md
  audit/
    inventory.json
    drift-report.md
    findings/

This is useful because AI agents need memory.

Not memory like "remember my favorite color".

Project memory like:

What architecture did we choose?
Where should new code go?
What legacy code should not be copied?
Which security rules matter?
Which tests are required?
What decisions have already been made?

Without this, every new AI session starts from zero.

Drift Detection

Another useful idea is drift detection.

Drift means the docs and the code no longer agree.

For example, the docs say:

All database access must go through repositories.

But later someone adds a controller that calls the database directly.

That is drift.

The skill can create a drift report so future agents do not blindly trust stale documentation.

CI Quality Gate

The skill can also be used as a CI-style review gate.

For example, on a pull request it can check:

Did this change violate architecture boundaries?
Did it introduce a security problem?
Did it change an API without updating docs?
Did it touch auth without tests?
Did it add a new dependency without a decision?

This can be advisory or blocking depending on the project.

Installing in Cursor

For Cursor, I use it as a project tool:

git submodule add https://github.com/lablnet/full-stack-quality-skill.git .cursor/tools/full-stack-quality

Then create:

.cursor/rules/full-stack-quality.mdc

With:

---
description: "Full-stack quality review for database, backend, frontend, APIs, GraphQL, security, testing, performance, observability, delivery, and utilities."
---

Read .cursor/tools/full-stack-quality/SKILL.md and follow it.

Then I can ask:

Use full-stack-quality to audit the whole project read-only.
Run all relevant auditors in parallel.
Create review.md and findings/<area>.findings.json files.

Installing in Codex

For Codex-style agents:

git submodule add https://github.com/lablnet/full-stack-quality-skill.git tools/full-stack-quality

Then add this to AGENTS.md:

For full-stack quality reviews, read tools/full-stack-quality/SKILL.md
and follow it. Supporting files are in the same folder.

What I Learned

The biggest lesson is that AI coding agents need structure.

A better prompt helps.

But a reusable skill is much better.

It gives the agent:

standards
examples
review rules
output formats
safety boundaries
project memory
CI review behavior

And once it is in the repo, the whole team can use the same rules.

Final Thought

AI coding tools are powerful, but power without taste and boundaries can make a codebase worse.

This skill is my attempt to give AI agents better engineering judgment.

Not by making them slower.

By making them more consistent.

If you want to try it:

https://github.com/lablnet/full-stack-quality-skill

Introducing HyperFlow: The Framework Where AI Writes Its Own Code!

Muhammad Umer Farooq — Sat, 11 Apr 2026 03:48:43 +0000

Hey everyone,

What if AI could fix its own mistakes without a human developer typing a single line of code? Today, I am thrilled to share an experimental project I have been exploring called HyperFlow.

Built on top of LangChain and LangGraph, HyperFlow is a self-improving agent framework. Instead of manually tuning an AI, we let another AI do the heavy lifting. Here is a detailed breakdown of how this fascinating system actually works!

The Core Concept: Two Agents Working Together

Usually, when an AI fails a task, a human has to step in and rewrite the prompt or fix the logic. HyperFlow automates this by using two different agents:

The TaskAgent (The Worker): This is the agent that actually solves the problems. You give it a task (like writing a bash command or solving a math problem), and it tries its best to give you the right prediction. It is simple and follows instructions.
The MetaAgent (The Improver): This is where the magic happens. The MetaAgent is the teacher. It looks at the TaskAgent's mistakes, reads the exact errors, and then rewrites the actual Python code, prompts, and tools to fix the problem. It is basically an AI acting as a software engineer!

The Evolutionary Loop

HyperFlow does not just try once; it learns over time using an evolutionary loop, just like biology!

Select: It picks a past version of the agent from its Archive.
Mutate: The MetaAgent reads the bad scores and edits the code files to improve the logic.
Evaluate: The new, updated TaskAgent runs in a safe sandbox to see if it scores better.
Save: If the AI is smarter, it gets saved to the Archive to be the parent of the next generation!

By repeating this loop, the agent naturally evolves to achieve higher success rates without any manual human intervention.

Mind-Blowing Features

Self-Referential Improvement: The MetaAgent can even edit its own instructions! It learns how to become a better teacher over time.
Smart Stopping: If the agent reaches a perfect 100 percent score, the loop stops automatically so you do not waste API tokens.
Safe Sandboxing: Because the AI is writing real code, you can run the whole loop inside isolated Docker containers to keep your computer safe. 🐳

The Current Limits

Because this is an experimental framework, there are a few things to keep in mind:

The underlying Foundation Model (like GPT-4o or Claude) does not change. HyperFlow only improves the code and prompts around the model.
Evolutionary computation takes time. Running 50 to 100 generations requires patience and API tokens!

If you want to dive deeper and see the code, you can explore the full documentation here: HyperFlow Documentation 🔗

Let's Discuss!

I am incredibly excited about the future of self-improving AI. The idea that systems can autonomously debug and rewrite their own logic opens up so many possibilities.

What is your take on this? Do you think self-improving agents are the next big leap in software development? Let me know your thoughts in the comments below! I will be reading and replying to them all.

*Inspired by HyperAgents (Meta Research, 2026).

Checkout My New Portfolio

Muhammad Umer Farooq — Wed, 17 Aug 2022 09:24:20 +0000

Hello Folks Let's have a look to my Portfolio.

https://www.lablnet.com/

Features

Dark theme support.
Responsive design.
Customizable.
Modern web technology.
Generate Sitemap base on vue-router.
Minumial but eye-catching UI.

This is open source under MIT License.

https://github.com/lablnet/lablnet.com

Open Source Super Fast Covid19 Parser and Dashboard

Muhammad Umer Farooq — Mon, 31 May 2021 02:12:27 +0000

COVID-19 Dashboard and parser

Open Source Super Fast COVID-19 Dashboard and parser

Purpose

Develop awareness among the public.
Visualized the data for everyone to understand.
Gather data for research/experiences.

Features

Parse data from government websites automatically daily, automated using GitHub Action of multiple countries.
Parse data from WHO automatically on every Monday, automated using GitHub Actions
Dashboard to visualize data.
Publicly Data downloading.
Multiple country handling frontend.
Super Fast performance
Fully customizable for country website for more info look Contribution guideline

repo link: https://github.com/lablnet/covid19
Web link: https://www.covid19.earth