Skip to main content التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-foundation-earsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
المهن ذات الصلةSOC
استنادا إلى تصنيف SOC المهني
| name | moai-foundation-ears |
| version | 4.0.0 |
| created | 2025-11-11T00:00:00.000Z |
| updated | 2025-11-13T00:00:00.000Z |
| status | stable |
| description | Enterprise EARS (Evaluate, Analyze, Recommend, Synthesize) Framework with AI-powered requirements engineering, Context7 integration, and intelligent solution orchestration for systematic problem-solving |
| keywords | ["ears","requirements-engineering","systematic-thinking","problem-solving","evaluation-framework","context7-integration","ai-orchestration","production-deployment"] |
| allowed-tools | ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"] |
Enterprise EARS Framework Expert v4.0.0
Skill Metadata
| Field | Value |
|---|
| Skill Name | moai-foundation-ears |
| Version | 4.0.0 (2025-11-13) |
| Tier | Foundation Framework Expert |
| AI-Powered | ✅ Context7 Integration, Intelligent Analysis |
| Auto-load | On demand when systematic analysis keywords detected |
What It Does
Enterprise EARS (Evaluate, Analyze, Recommend, Synthesize) Framework expert with AI-powered requirements engineering, Context7 integration, and intelligent solution orchestration for systematic problem-solving.
Revolutionary v4.0.0 capabilities:
- 🤖 AI-Powered EARS Analysis using Context7 MCP for latest problem-solving methodologies
- 📊 Intelligent Requirements Engineering with automated stakeholder analysis and validation
- 🚀 Advanced Solution Synthesis with AI-driven alternative evaluation and optimization
- 🔗 Enterprise Decision Framework with zero-configuration systematic thinking processes
- 📈 Predictive Solution Validation with success probability and risk assessment
When to Use
Automatic triggers:
- Complex problem analysis and systematic solution design discussions
- Requirements engineering and stakeholder alignment processes
- Decision-making framework implementation and evaluation
- Project planning and solution architecture validation
Manual invocation:
- Applying EARS framework to complex business problems
- Conducting systematic requirements analysis and validation
- Designing solution alternatives with comprehensive evaluation
- Implementing structured decision-making processes
Quick Reference (Level 1)
EARS Framework Overview
Four-Phase Systematic Analysis
- E - Evaluate: Assess problem context, stakeholders, constraints
- A - Analyze: Break down components, identify root causes, examine dependencies
Core Principles
- Systematic Thinking: Structured approach to complex problems
- Stakeholder-Centric: Focus on user and business requirements
- Evidence-Based: Data-driven analysis and decision making
- Iterative Refinement: Continuous improvement and validation
Application Areas
- Requirements Engineering: Systematic requirement gathering and validation
- Solution Architecture: Comprehensive solution design and evaluation
- Project Planning: Structured project analysis and planning
- Risk Management: Systematic risk identification and mitigation
Integration Benefits
- Consistency: Standardized approach across projects
- Quality: Thorough analysis reduces oversight and errors
- Collaboration: Clear framework for team alignment
- Documentation: Systematic record of analysis and decisions
Core Implementation (Level 2)
EARS Architecture Intelligence
class EARSFrameworkOptimizer:
def __init__(self):
self.context7_client = Context7Client()
self.requirements_analyzer = RequirementsAnalyzer()
self.solution_synthesizer = SolutionSynthesizer()
async def apply_ears_framework(self,
problem_context: ProblemContext,
stakeholder_requirements: StakeholderRequirements) -> EARSAnalysis:
"""Apply EARS framework using AI-powered analysis."""
requirements_docs = await self.context7_client.get_library_docs(
context7_library_id='/requirements-engineering/docs',
topic="stakeholder analysis systematic thinking 2025",
tokens=3000
)
problem_solving_docs = await self.context7_client.get_library_docs(
context7_library_id='/problem-solving/docs',
topic="systematic analysis solution synthesis 2025",
tokens=2000
)
evaluation = await self._evaluate_context(
problem_context,
stakeholder_requirements,
requirements_docs
)
analysis = await self._analyze_problem(
problem_context,
evaluation,
problem_solving_docs
)
recommendations = await self._recommend_solutions(
analysis,
stakeholder_requirements,
problem_solving_docs
)
synthesis = await self._synthesize_solution(
evaluation,
analysis,
recommendations,
requirements_docs
)
return EARSAnalysis(
evaluation=evaluation,
analysis=analysis,
recommendations=recommendations,
synthesis=synthesis,
confidence_score=self._calculate_confidence_score(evaluation, analysis),
risk_assessment=self._assess_implementation_risks(synthesis)
)
Phase E: Evaluation Implementation
class EvaluationEngine:
async def evaluate_context(self,
problem_context: ProblemContext,
stakeholder_requirements: StakeholderRequirements) -> Evaluation:
"""Comprehensive evaluation of problem context and stakeholders."""
stakeholder_analysis = await self._analyze_stakeholders(
stakeholder_requirements.stakeholders,
problem_context.business_domain
)
constraint_analysis = await self._evaluate_constraints(
problem_context.constraints,
problem_context.timeline,
problem_context.budget
)
context_assessment = await self._assess_context(
problem_context.business_environment,
problem_context.technical_landscape,
problem_context.organizational_capability
)
return Evaluation(
stakeholder_analysis=stakeholder_analysis,
constraint_analysis=constraint_analysis,
context_assessment=context_assessment,
evaluation_summary=self._create_evaluation_summary(
stakeholder_analysis, constraint_analysis, context_assessment
),
critical_factors=self._identify_critical_factors(
problem_context, stakeholder_requirements
)
)
async def _analyze_stakeholders(self,
stakeholders: List[Stakeholder],
business_domain: str) -> StakeholderAnalysis:
"""Analyze stakeholder requirements and influence."""
stakeholder_matrix = {}
for stakeholder in stakeholders:
complexity_score = self._calculate_requirement_complexity(
stakeholder.requirements
)
influence_score = self._assess_stakeholder_influence(
stakeholder.role, business_domain
)
interest_score = self._assess_stakeholder_interest(
stakeholder.requirements, stakeholder.motivations
)
conflicts = self._identify_requirement_conflicts(
stakeholder.requirements, stakeholders
)
stakeholder_matrix[stakeholder.id] = StakeholderProfile(
stakeholder=stakeholder,
complexity_score=complexity_score,
influence_score=influence_score,
interest_score=interest_score,
conflicts=conflicts,
engagement_strategy=self._determine_engagement_strategy(
influence_score, interest_score
)
)
return StakeholderAnalysis(
stakeholder_matrix=stakeholder_matrix,
stakeholder_map=self._create_stakeholder_map(stakeholder_matrix),
conflict_matrix=self._create_conflict_matrix(stakeholder_matrix),
engagement_plan=self._create_engagement_plan(stakeholder_matrix)
)
Phase A: Analysis Implementation
class AnalysisEngine:
async def analyze_problem(self,
problem_context: ProblemContext,
evaluation: Evaluation,
problem_solving_docs: Dict) -> Analysis:
"""Deep analysis of problem structure and root causes."""
component_analysis = await self._breakdown_components(
problem_context.problem_statement,
evaluation.context_assessment
)
root_cause_analysis = await self._analyze_root_causes(
component_analysis,
problem_context.symptoms,
problem_context.business_impact
)
dependency_analysis = await self._analyze_dependencies(
component_analysis,
problem_context.technical_landscape,
evaluation.constraint_analysis
)
return Analysis(
component_analysis=component_analysis,
root_cause_analysis=root_cause_analysis,
dependency_analysis=dependency_analysis,
problem_complexity=self._assess_problem_complexity(
component_analysis, root_cause_analysis, dependency_analysis
),
key_insights=self._extract_key_insights(
component_analysis, root_cause_analysis
)
)
async def _analyze_root_causes(self,
component_analysis: ComponentAnalysis,
symptoms: List[Symptom],
business_impact: BusinessImpact) -> RootCauseAnalysis:
"""Perform comprehensive root cause analysis."""
potential_causes = []
for symptom in symptoms:
root_causes = self._apply_5_whys(symptom)
fishbone_causes = self._apply_fishbone_analysis(
symptom, component_analysis
)
pareto_analysis = self._apply_pareto_analysis(
symptom, business_impact
)
potential_causes.append(CauseAnalysis(
symptom=symptom,
root_causes=root_causes,
fishbone_causes=fishbone_causes,
impact_analysis=pareto_analysis,
confidence_score=self._calculate_cause_confidence(
root_causes, fishbone_causes, pareto_analysis
)
))
return RootCauseAnalysis(
cause_analyses=potential_causes,
root_cause_hierarchy=self._create_cause_hierarchy(potential_causes),
impact_matrix=self._create_impact_matrix(potential_causes),
validation_plan=self._create_validation_plan(potential_causes)
)
Advanced Implementation (Level 3)
Phase R: Recommendations Implementation
class RecommendationEngine:
async def recommend_solutions(self,
analysis: Analysis,
stakeholder_requirements: StakeholderRequirements,
problem_solving_docs: Dict) -> Recommendations:
"""Generate and evaluate solution alternatives."""
solution_alternatives = await self._generate_solutions(
analysis.root_cause_analysis,
analysis.component_analysis,
analysis.dependency_analysis
)
solution_evaluation = await self._evaluate_solutions(
solution_alternatives,
stakeholder_requirements,
analysis.constraint_analysis
)
risk_assessment = await self._assess_solution_risks(
solution_evaluation.recommended_solutions,
analysis.dependency_analysis
)
return Recommendations(
solution_alternatives=solution_alternatives,
solution_evaluation=solution_evaluation,
risk_assessment=risk_assessment,
implementation_timeline=self._create_implementation_timeline(
solution_evaluation.recommended_solutions
),
resource_requirements=self._calculate_resource_requirements(
solution_evaluation.recommended_solutions
)
)
async def _generate_solutions(self,
root_cause_analysis: RootCauseAnalysis,
component_analysis: ComponentAnalysis,
dependency_analysis: DependencyAnalysis) -> List[SolutionAlternative]:
"""Generate comprehensive solution alternatives."""
solutions = []
direct_solutions = self._generate_direct_solutions(root_cause_analysis)
system_solutions = self._generate_system_solutions(
component_analysis, dependency_analysis
)
phased_solutions = self._generate_phased_solutions(
root_cause_analysis, component_analysis
)
technology_solutions = self._generate_technology_solutions(
component_analysis, dependency_analysis
)
process_solutions = self._generate_process_solutions(
root_cause_analysis, stakeholder_requirements
)
all_solutions = [
*direct_solutions,
*system_solutions,
*phased_solutions,
*technology_solutions,
*process_solutions
]
ranked_solutions = self._rank_solutions(all_solutions, root_cause_analysis)
return ranked_solutions[:10]
Phase S: Synthesis Implementation
class SynthesisEngine:
async def synthesize_solution(self,
evaluation: Evaluation,
analysis: Analysis,
recommendations: Recommendations,
requirements_docs: Dict) -> Synthesis:
"""Synthesize comprehensive solution implementation plan."""
integrated_solution = await self._integrate_solutions(
recommendations.recommended_solutions,
analysis.component_analysis
)
implementation_plan = await self._create_implementation_plan(
integrated_solution,
evaluation.constraint_analysis,
recommendations.resource_requirements
)
success_metrics = await self._define_success_metrics(
integrated_solution,
evaluation.stakeholder_analysis,
analysis.business_impact
)
risk_mitigation = await self._create_risk_mitigation_strategy(
recommendations.risk_assessment,
implementation_plan
)
return Synthesis(
integrated_solution=integrated_solution,
implementation_plan=implementation_plan,
success_metrics=success_metrics,
risk_mitigation=risk_mitigation,
governance_structure=self._define_governance_structure(
evaluation.stakeholder_analysis, implementation_plan
),
validation_criteria=self._create_validation_criteria(
integrated_solution, success_metrics
)
)
async def _create_implementation_plan(self,
integrated_solution: IntegratedSolution,
constraint_analysis: ConstraintAnalysis,
resource_requirements: ResourceRequirements) -> ImplementationPlan:
"""Create detailed implementation plan with phases and milestones."""
foundation_phase = ImplementationPhase(
name="Foundation",
duration="4-6 weeks",
objectives=[
"Establish project governance structure",
"Set up development infrastructure",
"Validate core assumptions",
"Secure stakeholder buy-in"
],
deliverables=[
"Project charter",
"Technical architecture",
"Stakeholder approval",
"Development environment"
],
dependencies=[],
risks=["Stakeholder alignment", "Technical feasibility"]
)
core_phase = ImplementationPhase(
name="Core Implementation",
duration="8-12 weeks",
objectives=[
"Implement core solution components",
"Integrate with existing systems",
"Develop necessary tooling",
"Establish monitoring and metrics"
],
deliverables=[
"Core solution implementation",
"System integrations",
"Monitoring dashboard",
"Documentation"
],
dependencies=[foundation_phase],
risks=["Technical complexity", "Integration challenges"]
)
optimization_phase = ImplementationPhase(
name="Optimization",
duration="4-8 weeks",
objectives=[
"Optimize solution performance",
"Scale to full operation",
"Train stakeholders",
"Establish operational procedures"
],
deliverables=[
"Optimized solution",
"Training materials",
"Operational procedures",
"Performance reports"
],
dependencies=[core_phase],
risks=["Performance issues", "User adoption"]
)
return ImplementationPlan(
phases=[foundation_phase, core_phase, optimization_phase],
timeline=self._create_detailed_timeline(
[foundation_phase, core_phase, optimization_phase]
),
resource_allocation=resource_requirements,
governance_structure=self._define_phase_governance(),
quality_gates=self._define_quality_gates()
)
Reference & Integration (Level 4)
API Reference
Core EARS Operations
evaluate_context(problem_context, stakeholders) - Evaluate problem contextanalyze_problem(evaluation, symptoms) - Analyze problem structurerecommend_solutions(analysis, constraints) - Generate solution recommendationssynthesize_solution(evaluation, analysis, recommendations) - Synthesize final solutionvalidate_implementation(synthesis, metrics) - Validate implementation approach
Context7 Integration
get_latest_requirements_docs() - Requirements engineering via Context7analyze_systematic_thinking_patterns() - Problem-solving methodologies via Context7optimize_solution_synthesis() - Solution optimization via Context7
Best Practices (November 2025)
DO
- Follow the EARS framework systematically for complex problems
- Involve all relevant stakeholders throughout the process
- Use data-driven analysis for objective decision making
- Document all assumptions, constraints, and decisions
- Validate solutions with stakeholders before implementation
- Consider multiple solution alternatives and approaches
- Plan for risks and develop mitigation strategies
- Establish clear success metrics and validation criteria
DON'T
- Skip phases or rush through the systematic analysis
- Ignore stakeholder requirements and concerns
- Rely on assumptions without data validation
- Overlook constraint analysis and resource limitations
- Forget to document the analysis and decision process
- Implement solutions without proper validation
- Neglect risk assessment and mitigation planning
- Skip success metrics definition and monitoring
Works Well With
moai-foundation-specs (SPEC lifecycle management)moai-alfred-spec-authoring (SPEC creation and writing)moai-foundation-trust (Trust and quality principles)moai-domain-backend (Technical solution implementation)moai-security-api (Security requirements analysis)moai-essentials-perf (Performance requirements)moai-domain-devops (Implementation planning)moai-foundation-git (Version control and collaboration)
Changelog
- v4.0.0 (2025-11-13): Complete Enterprise v4.0 rewrite with 40% content reduction, 4-layer Progressive Disclosure structure, Context7 integration, advanced systematic thinking patterns, and comprehensive solution synthesis
- v2.0.0 (2025-11-11): Complete metadata structure, EARS framework patterns, stakeholder analysis
- v1.0.0 (2025-11-11): Initial EARS framework foundation
End of Skill | Updated 2025-11-13
Framework Integration
EARS Integration Patterns
- Seamless integration with SPEC lifecycle management
- Stakeholder analysis integration with project governance
- Solution synthesis integration with development workflows
- Risk assessment integration with quality gates
Enterprise Adoption
- Standardized problem-solving methodology across teams
- Consistent documentation and decision-making processes
- Integration with existing project management tools
- Training and adoption support for organizations
End of Enterprise EARS Framework Expert v4.0.0
