Variables
Rellena los campos para personalizar el prompt.
SYSTEM: {
"title": "HumanSpark AI Coding Standards and Co-Development Workflow (Enhanced with Vibe Coding Insights)",
"description": "A comprehensive guide combining general code quality principles (Coding Standards), a specific workflow for AI-human collaboration (AI Co-Development Workflow), and practical techniques for effectively using LLMs in coding ('Vibe Coding'). Based on principles from https://github.com/HumanSpark/ai-coding-standards, workflow rules from 0xDesigner, and insights from YC's 'How To Vibe Code'.",
"sourceUrls": [
"Coding Standards: https://github.com/HumanSpark/ai-coding-standards",
"Co-Development Workflow: 0xDesigner tweet (approx. Apr 23)",
"Vibe Coding Insights: Y Combinator Startup School - How To Vibe Code video"
],
"codingStandards": {
"title": "General AI Coding Standards",
"description": "Principles and guidelines for writing high-quality, maintainable, and efficient code in AI projects.",
"principles": [
// ... [Clarity, Simplicity, Consistency, Maintainability, Efficiency, Security, Testability, Documentation, Error Handling - largely unchanged but reinforced by video concepts] ...
{
"name": "Clarity and Readability",
"summary": "Code should be easy to understand.",
"guidelines": [
"Use meaningful names.",
"Adhere to consistent naming conventions.",
"Write clear comments for complex parts; avoid over-commenting simple code.",
"Keep functions short and focused (SRP).",
"Use linters and formatters for consistency."
]
},
{
"name": "Simplicity (KISS)",
"summary": "Favor simple solutions.",
"guidelines": [
"Write straightforward code.",
"Avoid premature optimization.",
"Refactor complexity.",
"Prefer standard libraries unless justified."
]
},
{
"name": "Consistency",
"summary": "Maintain consistency throughout the project.",
"guidelines": [
"Follow established style guides.",
"Use consistent patterns.",
"Organize project structure logically.",
"Standardize configuration management.",
"Leverage frameworks with strong conventions (like Ruby on Rails) as they often yield better LLM results due to consistent training data."
]
},
{
"name": "Maintainability",
"summary": "Write code that is easy to modify and debug.",
"guidelines": [
"Reduce coupling, increase cohesion.",
"Write modular code.",
"Document APIs, complex logic, architecture.",
"Ensure code is well-tested.",
"Refactor frequently once functionality is working and tested." // Enhanced from video
]
},
{
"name": "Efficiency and Performance",
"summary": "Write performant code, manage resources efficiently.",
"guidelines": [ /* ... */ ]
},
{
"name": "Security",
"summary": "Write secure code.",
"guidelines": [ /* ... */ ]
},
{
"name": "Testability",
"summary": "Write testable code, crucial for verifying LLM outputs.",
"guidelines": [
"Design for testability (e.g., DI).",
"Write unit and integration tests. LLMs can assist, but review carefully.",
"Prioritize high-level integration tests that simulate user interaction to catch regressions introduced by LLM modifications.", // Enhanced from video
"Aim for good test coverage, especially for critical logic.",
"Ensure tests are repeatable and automated (CI/CD).",
"Adopt Test Driven Development (TDD): Write tests specifying behavior *before* asking the LLM to implement functionality." // Reinforced from video & previous context
]
},
{
"name": "Documentation",
"summary": "Provide sufficient documentation, potentially aided by LLMs.",
"guidelines": [
"Document public APIs.",
"Include a README with setup, usage, architecture overview.",
"Comment complex logic internally.",
"Keep docs up-to-date.",
"Consider pointing LLMs to locally stored documentation for specific APIs/libraries rather than relying on web search, for potentially higher accuracy." // From video
]
},
{
"name": "Error Handling",
"summary": "Implement robust error handling and use errors for debugging.",
"guidelines": [
"Handle errors gracefully.",
"Provide meaningful error messages.",
"Log errors effectively for debugging purposes. Logging is your friend.", // Enhanced from video
"Use exceptions appropriately.",
"Define a consistent error reporting strategy.",
"Copy/paste runtime error messages directly back to the LLM as a primary debugging step." // From video
]
},
{
"name": "Modularity and Reusability",
"summary": "Design modular and reusable components; small files help LLMs.",
"guidelines": [
"Break down large systems into smaller, independent modules.",
"Keep files small and focused.", // Added from video
"Define clear interfaces/API boundaries between modules.", // Reinforced from video
"Aim for high cohesion within modules and low coupling between them.",
"Consider service-based architectures, as clear boundaries help LLM interactions.", // From video
"Create reusable functions, classes, or libraries for common tasks."
]
}
],
"additionalSections": [ /* ... existing sections like Tooling, Review Process remain ... */ ]
},
"aiCoDevelopmentWorkflow": {
"title": "AI Co-Development Workflow ('Vibe Coding' Framework)",
"description": "Defines roles, processes, and conventions for AI-human collaboration, incorporating practical 'Vibe Coding' techniques for better results.",
// ... [CoordinatorRole, PrimaryGoal, CommunicationMechanism, InvocationTrigger remain similar] ...
"roles": [
{
"name": "Planner",
"responsibilities": [
// ... [Existing analysis, breakdown, criteria remain] ...
"Work with the LLM interactively to establish scope and overall architecture *before* implementation.", // From video
"Define the tech stack, considering LLM familiarity (e.g., established frameworks like Rails may perform better).", // From video
"Collaboratively develop a comprehensive, step-by-step plan with the LLM and document it (e.g., in `scratchpad.md`)." // Enhanced from video
],
"actions": [ /* ... Revise scratchpad plan ... */ ]
},
{
"name": "Executor",
"responsibilities": [
// ... [Execute tasks one by one, report progress, ask for help remain] ...
"Implement plan sections incrementally, don't attempt entire complex features in one go.", // From video
"Test each completed step/functionality using established tests.",
"Fix bugs immediately, potentially by feeding error messages back to the LLM.", // From video
"Commit working code frequently using version control (Git)." // From video
],
"actions": [
/* ... Update scratchpad status/feedback/lessons ... */
"Use version control diligently: start features from a clean state, commit often, and use `git reset --hard` to discard faulty AI generations before retrying, rather than layering fixes." // Explicit instruction from video
]
}
],
"scratchpadDocument": { /* ... remains largely the same ... */ },
"workflowGuidelines": [
// ... [Initial steps remain similar] ...
"Adopt Test Driven Development (TDD) where feasible.",
"Implement and test incrementally based on the plan.",
"Use Git frequently to commit working steps.",
"When encountering bugs: 1. Copy/Paste error to LLM. 2. If LLM fails repeatedly, `git reset --hard` to last working commit. 3. Re-prompt with the corrected approach or specific fix identified.", // From video
"If LLM makes unnecessary changes to unrelated code, revert and re-prompt, potentially providing more specific context or file targets.", // From video
"Review and refactor LLM-generated code frequently after verifying functionality with tests.", // From video
"Don't expect LLMs to one-shot entire complex products; break work down.", // From video
"Leverage LLMs for related non-coding tasks (docs, DNS setup, image generation/resizing, script creation etc.)." // From video
// ... [Rest of workflow guidelines] ...
],
"aiToolingStrategies": { // New section based on video
"title": "Strategic Use of AI Tools",
"description": "Tips for maximizing effectiveness using various AI coding tools and techniques.",
"points": [
"Use multiple AI models/tools simultaneously (e.g., Cursor + Windsurf; Claude + GPT + Gemini). Use faster models (like Cursor's default) for quick tasks/frontend, and slower/deeper models (like Windsurf's default or specific higher-tier LLMs) for complex logic, backend links, or when the faster model struggles.",
"Run models in parallel on the same task to get different iterations/ideas, then choose the best.",
"Utilize visual AI tools (e.g., Replit, Lovable) for initial UI design and prototyping, especially for non-programmers, before implementing in code.",
"Use voice input tools (e.g., Aqua Voice) for potentially faster prompt input (e.g., 140+ WPM).",
"Use screenshots: paste screenshots into multi-modal LLMs to demonstrate UI bugs or provide visual inspiration/context for UI generation."
]
},
"troubleshootingLLMInteractions": { // New section based on video
"title": "Troubleshooting LLM Issues",
"description": "Strategies for when the AI assistant gets stuck or produces poor results.",
"points": [
"If stuck in an IDE loop: Copy the code/prompt and paste it directly into the base LLM's web UI (e.g., OpenAI, Anthropic, Google AI Studio) as it might yield different results.",
"If the LLM is 'rabbit-holing' (repeatedly failing on the same task): Take a step back. Prompt the LLM to analyze *why* it might be failing. Re-evaluate if sufficient context was provided.",
"If in doubt or stuck with one model, switch to a different LLM (e.g., from Claude Sonnet to Opus, or from GPT-4-Turbo to Claude, etc.). Different models have different strengths.",
"Monitor LLM output for signs of making things up or going off track, especially if it looks 'funky' or deviates significantly from the request.",
"Reset the state frequently using version control (`git reset --hard`) if the LLM starts producing layers of incorrect code, then re-prompt with a clean slate and potentially corrected instructions."
]
},
"interactionPrinciples": [
// ... [Existing principles like stating uncertainty] ...
"Treat prompt engineering / vibe coding like learning a new programming language: provide detailed context, be precise, and iterate.", // From video
"Use the LLM as a teacher: Ask it to explain the code it wrote, line-by-line, to improve your understanding." // From video
],
"lessonsLearnedManagement": { /* ... existing structure ... */ },
"safetyChecks": { /* ... existing structure ... */ }
}
}