Netra

/buildmode

Headline

🌐 Netra 👁️: Solving AI Context Collapse with Dynamic Skill Forging

About the project

Inspiration

Using AI agents for large-scale software engineering is fragmented, unverifiable, and dangerous to your codebase.

If left unregulated with massive, generic system prompts, LLMs commit biblical levels of hallucination and break the environment.

Context collapse causes $$80\%$$ of AI agent failures in large repositories.
Shoving a $$100,000$$ token .cursorrules file into a prompt destroys the model's attention span.
Unchecked code generation introduces $$\$10^6$$ of technical debt in enterprise systems.

All of this happens because modern AI prompting is static and rigid. The root of all evil starts from the context window limitations—trying to hunt for the cheapest way to stuff an entire codebase's context into a single prompt. Instead of relying on a massive global system prompt built on "trusting the LLM," we were inspired to build a system to verify, dynamically forge, and orchestrate the AI software lifecycle.

What it does

Netra is a cross-platform AI orchestrator CLI that manages the entire software development lifecycle by sitting on top of existing coding agents (like Claude or Cursor).

Instead of acting as a standalone coder, Netra forces the AI through a rigorous pipeline: Discuss $$ \rightarrow $$ Plan $$ \rightarrow $$ Execute $$ \rightarrow $$ Verify.

Its standout feature is Dynamic Skill Forging. Instead of giving the AI a universal checklist, Netra reads the project evidence and generates a hyper-specific SKILL.md contract for only the feature it is currently building. This ensures $$ \mathcal{O}(1) $$ cognitive load for the LLM. If the AI fails a task, the netra-learn loop evaluates the evidence and dynamically updates the project's specific SKILL.md so the AI physically learns from its mistakes.

How we built it

We built a heavy, monolithic Node.js engine (bin/netra.mjs) that acts as the manager.

We moved state management out of the LLM context window and directly into the local file system.
We utilized meta-prompting heavily. Netra’s core loop involves asking the LLM to evaluate project requirements and then output a smaller, highly optimized prompt (a "Skill"), which is then fed back into the coding agent for the actual execution phase.
We created a suite of markdown-based commands (netra-plan, netra-execute, netra-verify) that act as strict contracts for the AI.

Challenges we ran into

None of us knew how to perfectly manage LLM state completely outside of the context window ☹️👎
Much less, know how to handle parallel agent wave execution, AST parsing, and dynamic markdown generation... everything... ☹️👎
But it's okay because we learned it, built it, and deployed it! 😎👍
Figuring out how to constrain the AI from visually hallucinating UI components was incredibly tough halfway through ☹️👎
But it's okay because we pivoted to strict code-first design tokens and it worked incredibly well! 😎👍

Accomplishments that we're proud of

Cracking Dynamic Forging: It is an incredibly difficult architectural pattern to pull off during a hackathon. Seeing the agent successfully generate its own localized rules instead of relying on a massive system prompt was a huge win.
State Management: Getting the core state machine robust enough to handle parallel execution without losing context or dropping files.
The Self-Learning Loop: Successfully implementing a system where the AI updates its own rules locally when it makes a mistake, solving the classic issue of LLMs repeating the same errors.

What we learned

We learned how to bridge local file-system state management with LLM API calls. We discovered that meta-prompting (using prompts to generate smaller, localized prompts) is exponentially more effective than single-shot system prompts. We also learned that to get an AI to write world-class code, you have to treat it like a compiler with strict mathematical rules, not a human developer.

What's next for Netra

UI/UX Template Overhaul: We plan to completely refactor the UI generation templates to pull exclusively from code-first component ecosystems (like Shadcn, Aceternity) instead of visual scraping.
Design Token Enforcement: We will implement a strict design token contract phase (enforcing HSL variables and spacing scales) before the AI is allowed to write any UI code.
Multi-Repo Orchestration: Expanding Netra's capabilities to manage deployments and backend orchestration across multiple microservice repositories simultaneously.

Built with

(Add these exact tags into your Devpost submission) nodejs javascript openai llm cli agents meta-prompting markdown json github api automation ai-architecture testing bash