skills.rest
AutumnsGrove
AutumnsGroveCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

elephant-build

Orchestrate multi-file software feature development through planning, construction, testing, and deployment phases.

5|Updated Nov 22, 2025
Search Tags:#workflow#testing#development#agile#coding#feature implementation
One-click install
npx skills add https://github.com/AutumnsGrove/Lattice --skill elephant-build
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: elephant-build
Source: https://github.com/AutumnsGrove/Lattice/tree/main/.claude/skills/elephant-build
Command: npx skills add https://github.com/AutumnsGrove/Lattice --skill elephant-build

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill streamlines the process of implementing complex features that span multiple files and systems, ensuring a structured and robust build process from conception to completion.

Core Features & Use Cases

  • Coordinated Development: Manages multi-file feature implementation, from database schema changes to frontend UI updates.
  • Phased Approach: Guides users through distinct build phases: TRUMPET (vision), GATHER (dependencies), BUILD (construction), TEST (verification), and CELEBRATE (completion).
  • Use Case: When developing a new user profile system that requires database schema updates, backend service logic, API endpoints, and frontend components, this Skill provides a clear roadmap and checklist to ensure all parts are built and integrated correctly.

Quick Start

Use the elephant-build skill to implement the new user profile feature, following all build phases.

Frequently Asked Questions about elephant-build

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

FAQPage Schema
How do I implement a multi-file software feature across database, API, and UI layers?▼

Multi-file feature implementation is orchestrated through structured phases of planning, resource gathering, construction, testing, and deployment to ensure databases, services, APIs, and user interfaces are built and integrated correctly.

What is the best way to manage complex feature development spanning multiple systems?▼

Complex feature development is managed through a phased approach that details file inventories, build sequences, and verification steps, providing a clear roadmap from conception to completion.

How do I structure a build sequence for a new user profile system with backend and frontend changes?▼

A build sequence for a user profile system is structured by guiding you through vision, dependency gathering, construction, testing, and completion phases to coordinate schema updates, backend logic, and frontend components.

Does this approach work for agile coding workflows that need comprehensive verification steps?▼

Yes, this approach fits agile coding workflows by integrating testing and verification steps into the construction phases, ensuring comprehensive implementation and momentum throughout the feature development lifecycle.

Can I use this to coordinate development when implementing features that require schema changes and API endpoints?▼

Yes, you can use this to coordinate development when implementing features requiring schema changes and API endpoints, as it manages multi-file feature implementation from database updates to frontend UI integration.

Related Skills

Explore More Software Engineering Skills→
alansmelloalansmello

speckit-tasks

Generate dependency-ordered tasks.md from design artifacts like plan.md and spec.md.

Community
Advanced
FoundationForgeFoundationForge

deploy-checklist

Generate pre-deployment checklists with rollback triggers and monitoring thresholds.

Official
Intermediate
willdadywilldady
63

to-tickets

Decomposes specs and plans into structured vertical-slice tickets with dependency mapping for GitHub or Linear.

Community
Advanced
mblodemblode
75

plan-feature

Generate implementation-ready plans and technical specs for complex changes.

Community
Intermediate