council-implement

Execute Carmack Council plans sequentially with type checking, linting, and tests.

51|8|Updated Mar 10, 2026
One-click install
npx skills add https://github.com/SamJHudson01/Carmack-Council --skill council-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: council-implement
Source: https://github.com/SamJHudson01/Carmack-Council/tree/main/skills/council-implement
Command: npx skills add https://github.com/SamJHudson01/Carmack-Council --skill council-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill automates the process of implementing software development plans, ensuring adherence to expert-driven principles and established coding conventions.

Core Features & Use Cases

  • Task-by-Task Implementation: Executes a given plan sequentially, task by task, respecting dependencies.
  • Expert Principle Integration: Loads and applies principles from relevant expert reference documents for each task.
  • Codebase Adherence: Matches existing codebase patterns, naming conventions, and file organization.
  • Verification: Ensures code quality through type checking, linting, and running existing tests after each task.
  • Use Case: After a /council-plan generates a detailed implementation strategy for a new feature, use /council-implement to translate that plan into actual, verified code.

Quick Start

Use the council implement skill to build the feature described in the provided council plan.

Frequently Asked Questions about council-implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code implementation from a development plan in Next.js and tRPC?

Automate code implementation by executing a development plan sequentially, task by task, matching existing codebase patterns and conventions within your Next.js, tRPC, Prisma, Neon, and Clerk stack to generate verified code.

What is task-by-task code generation with expert principles?

Task-by-task code generation with expert principles is the process of loading relevant expert reference documents for each specific task and applying those guidelines to write code that adheres to established architectural standards.

How do I ensure code integrity when implementing new features across a full stack?

Ensure code integrity by running type checking, linting, and existing tests after implementing each task, generating a detailed implementation log to verify adherence to codebase conventions and expert principles.

Can I use this implementation approach with an existing Prisma and Clerk codebase?

Yes, you can use this approach with an existing Prisma and Clerk codebase because it operates within a defined stack, prioritizing adherence to established file organization, naming conventions, and minimizing your overall code footprint.

What's the best way to translate an agile implementation strategy into actual code?

The best way to translate an agile implementation strategy into actual code is to execute the plan sequentially, respecting dependencies while loading reference documents to guide development and verify code quality through testing.

Do I need a pre-defined plan before starting automated code generation?

Yes, you need a pre-defined council plan before starting automated code generation because the process executes tasks sequentially from that detailed implementation strategy, respecting dependencies to build the described feature accurately.