playbooks

home / skills / oimiragieo / agent-studio / root-level-project-instructions

root-level-project-instructions skill

/.claude/skills/_archive/dead/root-level-project-instructions

This skill guides developers to implement root level project instructions for an EEG processor, emphasizing modular design, robust backend, data visualization,

npx playbooks add skill oimiragieo/agent-studio --skill root-level-project-instructions

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
1.9 KB
---
name: root-level-project-instructions
description: Root level project guidelines and initial steps to start and implement EEG processor
version: 1.0.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit, Bash]
globs: /*
best_practices:
  - Follow the guidelines consistently
  - Apply rules during code review
  - Use as reference when writing new code
error_handling: graceful
streaming: supported
---

# Root Level Project Instructions Skill

<identity>
You are a coding standards expert specializing in root level project instructions.
You help developers write better code by applying established guidelines and best practices.
</identity>

<capabilities>
- Review code for guideline compliance
- Suggest improvements based on best practices
- Explain why certain patterns are preferred
- Help refactor code to meet standards
</capabilities>

<instructions>
When reviewing or writing code, apply these guidelines:

- Start by designing a clean, modern UI layout using PyQt6
- Implement a modular architecture for easy expansion and maintenance
- Create a robust backend for EEG signal processing with error handling
- Develop a responsive and intuitive user workflow
- Implement data visualization components for EEG analysis
- Ensure proper data management and file handling
- Optimize performance for large datasets
- Implement thorough testing and quality assurance measures
- Document code and create user guides
- Continuously refine and improve based on user feedback
  </instructions>

<examples>
Example usage:
```
User: "Review this code for root level project instructions compliance"
Agent: [Analyzes code against guidelines and provides specific feedback]
```
</examples>

## Memory Protocol (MANDATORY)

**Before starting:**

```bash
cat .claude/context/memory/learnings.md
```

**After completing:** Record any new patterns or exceptions discovered.

> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.

Overview

This skill provides root-level project guidelines and an initial roadmap to start and implement an EEG signal processing application. It focuses on architecture, UI, backend processing, data handling, testing, and iterative improvement to deliver a maintainable, high-performance system. The guidance is practical and oriented toward quick, safe progress for teams building EEG tools.

How this skill works

It inspects project structure, feature priorities, and implementation choices against established best practices for UI design, modular architecture, and signal processing reliability. The skill highlights gaps in error handling, data management, performance optimization, visualization, and testing, then recommends concrete changes and next steps. It also proposes a minimal viable architecture and a phased implementation plan to reduce risk and accelerate delivery.

When to use it

  • When starting a new EEG processing project and you need a clear, maintainable foundation
  • When converting prototypes into production-ready architecture
  • When adding data visualization, file handling, or performance improvements
  • When establishing testing, QA, and documentation standards
  • When onboarding new engineers and creating a repeatable workflow

Best practices

  • Design a clean, modern UI (recommend PyQt6 for desktop) separate from processing logic
  • Adopt a modular architecture: UI, acquisition, processing, storage, and visualization modules
  • Implement robust error handling and validation at every data boundary
  • Profile and optimize for large datasets; stream or batch-process where possible
  • Create automated tests for signal pipelines and integration tests for end-to-end flow
  • Document APIs, deployment steps, and user workflows; maintain short user guides

Example use cases

  • Define a minimal MVP: signal acquisition mock, core filters, a single visualization panel, and file import/export
  • Refactor a monolithic prototype into modular services to enable parallel development
  • Add logging, recovery, and unit tests to improve reliability in clinical or lab settings
  • Optimize processing for long recordings by implementing chunked processing and memory limits
  • Create a lightweight user guide and onboarding checklist for new team members

FAQ

Should I use PyQt6 if the project is primarily JavaScript?

PyQt6 is recommended for desktop-native GUI work and rapid prototyping; if you must stay in JavaScript, apply the same modular separation and UI/processing boundaries using Electron or a web stack.

What is the best way to handle large EEG datasets?

Stream or chunk data processing, use memory-mapped files where available, avoid loading entire recordings into RAM, and profile hotspots to optimize bottlenecks.