majiayu000
majiayu000/claude-skill-registry
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/majiayu000/claude-skill-registry --skill sales-engineering命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
LLM token logprobs and calibration. Per-decision confidence, ECE, Brier, reliability diagrams, low-confidence triage.
Analyze LLM token logprobs and calibration. Use for per-decision confidence, ECE, Brier scores, reliability diagrams, and low-confidence triage.
回顾最近 N 天的 Claude Code 使用记录——扫描原始会话数据，按主题分组汇总"我都做了什么"，并从个人操作系统视角输出模式、风险与增删建议。当用户说 /recap、"看看我这几天做了什么"、"回顾一下我最近的会话"、"这两天我用 claude 干了啥"、"活动回顾" 时使用。
基于 SOC 职业分类
正在显示 SKILL.md
| name | Sales Engineering |
| description | Supporting sales with technical expertise, demos, and proof-of-concept implementations |
Sales Engineering enables supporting sales with technical expertise, demos, and proof-of-concept implementations. This capability is essential for bridging the gap between sales and engineering, demonstrating product value, and closing deals.
┌─────────────────────────────────────────────────────────────────────────────┐
│ Sales Engineering Framework │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Sales │ │ Technical │ │ Demo │ │
│ │ Support │───▶│ Expertise │───▶│ Creation │ │
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ Pre-Sales Activities │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Discovery│ │ Solution │ │ Demo │ │ PoC │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼────────────┼────────────┼────────────┼────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ Sales Support │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Objection │ │ Technical │ │ Pricing │ │ Contract │ │ │
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │
│ └───────┼────────────┼────────────┼────────────┼────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ Post-Sales Handoff │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Onboard │ │ Training │ │ Support │ │ Success │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
from typing import Dict, Any, List, Optional
from dataclasses import dataclass
from enum import Enum
import asyncio
import logging
from datetime import datetime
logger = logging.getLogger(__name__)
class OpportunityStage(Enum):
"""Opportunity stages"""
DISCOVERY = "discovery"
QUALIFICATION = "qualification"
SOLUTION_DESIGN = "solution_design"
DEMO = "demo"
PROPOSAL = "proposal"
NEGOTIATION = "negotiation"
CLOSED_WON = "closed_won"
CLOSED_LOST = "closed_lost"
class PoCStatus(Enum):
"""PoC status"""
PLANNED = "planned"
IN_PROGRESS = "in_progress"
COMPLETED = "completed"
ACCEPTED = "accepted"
REJECTED = "rejected"
@dataclass
class Opportunity:
"""Opportunity definition"""
opportunity_id: str
account_name: str
contact_name: str
stage: OpportunityStage
value: float
probability: float
requirements: List[str]
challenges: []
created_at:
updated_at:
:
demo_id:
opportunity_id:
title:
description:
features: []
use_cases: []
scheduled_at:
duration_minutes:
created_at:
:
poc_id:
opportunity_id:
title:
description:
scope: []
success_criteria: []
status: PoCStatus
start_date:
end_date:
created_at:
:
():
.config = config
.opportunity_store = OpportunityStore(config[])
.demo_creator = DemoCreator(config[])
.poc_builder = PoCBuilder(config[])
() -> [, ]:
logger.info()
requirements_analysis = ._analyze_requirements(opportunity)
challenges = ._identify_challenges(opportunity)
solutions = ._recommend_solutions(opportunity, requirements_analysis, challenges)
results = {
: opportunity.opportunity_id,
: requirements_analysis,
: challenges,
: solutions,
: datetime.utcnow().isoformat()
}
logger.info()
results
() -> [, ]:
analysis = {
: [],
: [],
: [],
: [],
: []
}
requirement opportunity.requirements:
req_type = ._categorize_requirement(requirement)
analysis[].append(requirement)
analysis
() -> :
requirement.lower():
requirement.lower():
requirement.lower():
requirement.lower():
:
() -> [[, ]]:
challenges = []
challenge opportunity.challenges:
challenge_analysis = {
: challenge,
: ._assess_severity(challenge),
: ._suggest_mitigation(challenge)
}
challenges.append(challenge_analysis)
challenges
() -> :
challenge.lower():
challenge.lower():
:
() -> :
() -> [[, ]]:
solutions = []
req_type, requirements requirements_analysis.items():
requirements:
solution = {
: req_type.replace(, ),
: requirements,
: ._propose_solution(req_type, requirements),
: ._estimate_effort(req_type, requirements),
: ._estimate_timeline(req_type, requirements)
}
solutions.append(solution)
challenge challenges:
challenge[] == :
solution = {
: ,
: challenge[],
: challenge[],
: ,
:
}
solutions.append(solution)
solutions
() -> :
() -> :
() -> :
() -> Demo:
logger.info()
demo_id = ._generate_demo_id()
demo = .demo_creator.create_demo(
demo_id=demo_id,
opportunity_id=opportunity.opportunity_id,
title=,
description=._generate_demo_description(opportunity),
features=._select_demo_features(opportunity),
use_cases=._select_use_cases(opportunity),
scheduled_at=._schedule_demo(opportunity),
duration_minutes=
)
logger.info()
demo
() -> :
() -> []:
[]
() -> []:
[]
() -> :
datetime.utcnow().isoformat()
() -> ProofOfConcept:
logger.info()
poc_id = ._generate_poc_id()
scope = ._define_poc_scope(opportunity)
success_criteria = ._define_success_criteria(opportunity)
poc = .poc_builder.build_poc(
poc_id=poc_id,
opportunity_id=opportunity.opportunity_id,
title=,
description=._generate_poc_description(opportunity),
scope=scope,
success_criteria=success_criteria,
status=PoCStatus.PLANNED,
start_date=._calculate_poc_start_date(),
end_date=._calculate_poc_end_date()
)
logger.info()
poc
() -> []:
[]
() -> []:
[]
() -> :
() -> :
datetime timedelta
start_date = datetime.utcnow() + timedelta(weeks=)
start_date.isoformat()
() -> :
datetime timedelta
end_date = datetime.utcnow() + timedelta(weeks=)
end_date.isoformat()
() -> :
uuid
() -> :
uuid
:
():
.config = config
() -> Demo:
._create_demo_environment(demo_id)
._configure_demo_data(demo_id, features)
demo = Demo(
demo_id=demo_id,
opportunity_id=opportunity_id,
title=title,
description=description,
features=features,
use_cases=use_cases,
scheduled_at=scheduled_at,
duration_minutes=duration_minutes,
created_at=datetime.utcnow().isoformat()
)
demo
():
():
:
():
.config = config
() -> ProofOfConcept:
._create_poc_environment(poc_id)
._implement_poc(poc_id, scope)
._test_poc(poc_id, success_criteria)
poc = ProofOfConcept(
poc_id=poc_id,
opportunity_id=opportunity_id,
title=title,
description=description,
scope=scope,
success_criteria=success_criteria,
status=status,
start_date=start_date,
end_date=end_date,
created_at=datetime.utcnow().isoformat()
)
poc
():
():
():
:
():
.config = config
():
() -> Opportunity:
():
class SalesSupport:
"""Sales support specialist"""
def __init__(self, config: Dict[str, Any]):
self.config = config
self.objection_handler = ObjectionHandler(config['objections'])
self.pricing_specialist = PricingSpecialist(config['pricing'])
self.contract_specialist = ContractSpecialist(config['contracts'])
async def handle_objections(
self,
opportunity: Opportunity,
objections: List[str]
) -> Dict[str, Any]:
"""Handle sales objections"""
logger.info(f"Handling objections for opportunity: {opportunity.opportunity_id}")
# Analyze objections
analyzed_objections = await self._analyze_objections(objections)
# Prepare responses
responses = await self._prepare_objection_responses(analyzed_objections)
# Compile results
results = {
'opportunity_id': opportunity.opportunity_id,
'objections': analyzed_objections,
'responses': responses,
'handled_at': datetime.utcnow().isoformat()
}
logger.info(f"Objections handled: {opportunity.opportunity_id}")
results
() -> [[, ]]:
analyzed = []
objection objections:
analysis = {
: objection,
: ._categorize_objection(objection),
: ._assess_objection_severity(objection),
: ._identify_root_cause(objection)
}
analyzed.append(analysis)
analyzed
() -> :
objection.lower():
objection.lower():
objection.lower():
objection.lower():
:
() -> :
() -> :
() -> [[, ]]:
responses = []
objection analyzed_objections:
response = {
: objection[],
: objection[],
: ._generate_response(objection),
: ._gather_evidence(objection),
: ._suggest_follow_up(objection)
}
responses.append(response)
responses
() -> :
() -> []:
[]
() -> :
() -> [, ]:
logger.info()
value_analysis = ._analyze_opportunity_value(opportunity)
pricing_model = .pricing_specialist.recommend_pricing_model(
opportunity,
value_analysis
)
pricing = .pricing_specialist.calculate_pricing(
opportunity,
pricing_model
)
results = {
: opportunity.opportunity_id,
: value_analysis,
: pricing_model,
: pricing,
: datetime.utcnow().isoformat()
}
logger.info()
results
() -> [, ]:
{
: opportunity.value,
: [],
: {}
}
() -> [, ]:
logger.info()
contract_terms = .contract_specialist.prepare_contract_terms(opportunity)
negotiation_points = ._identify_negotiation_points(opportunity)
negotiation_strategy = ._prepare_negotiation_strategy(
contract_terms,
negotiation_points
)
results = {
: opportunity.opportunity_id,
: contract_terms,
: negotiation_points,
: negotiation_strategy,
: datetime.utcnow().isoformat()
}
logger.info()
results
() -> [, ]:
{
: [],
: [],
: [],
: []
}
() -> [[, ]]:
[]
:
():
.config = config
:
():
.config = config
() -> :
() -> [, ]:
{}
:
():
.config = config
() -> [, ]:
{}
# config/sales_engineering_config.yaml
sales_engineering:
discovery:
enabled: true
methods:
- "discovery_call"
- "technical_assessment"
- "requirements_gathering"
deliverables:
- "requirements_document"
- "solution_proposal"
- "architecture_diagram"
demo:
enabled: true
duration_minutes: 60
preparation_time: "2-4 hours"
environment:
type: "sandbox"
data_source: "demo_data"
refresh_frequency: "daily"
features:
customization: true
branding: true
use_case_specific: true
poc:
enabled: true
duration_weeks: 4
scope:
max_features: 5
max_integrations: 3
max_users: 10
success_criteria:
# sales_engineering/workflow.py
import asyncio
import logging
from typing import Dict, Any
from sales_engineering.engineer import SalesEngineer
from sales_engineering.support import SalesSupport
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
async def run_sales_engineering():
"""Run sales engineering workflow"""
logger.info("=" * 60)
logger.info("Sales Engineering Workflow")
logger.info("=" * 60)
# Load configuration
config = load_config('config/sales_engineering_config.yaml')
# Create opportunity
opportunity = create_sample_opportunity()
# Step 1: Support discovery
logger.info("\n" + "=" * 60)
logger.info("Step 1: Supporting Discovery")
logger.info("=" * 60)
engineer = SalesEngineer(config)
discovery_results = await engineer.support_discovery(opportunity)
logger.info("Discovery supported")
print_discovery_results(discovery_results)
# Step 2: Create demo
logger.info("\n" + "=" * 60)
logger.info("Step 2: Creating Demo")
logger.info("=" * 60)
demo = await engineer.create_demo(opportunity)
logger.info(f"Demo created: {demo.demo_id}")
print_demo_summary(demo)
logger.info( + * )
logger.info()
logger.info( * )
poc = engineer.build_poc(opportunity)
logger.info()
print_poc_summary(poc)
logger.info( + * )
logger.info()
logger.info( * )
support = SalesSupport(config)
objections = [
,
,
]
objection_results = support.handle_objections(opportunity, objections)
logger.info()
print_objection_results(objection_results)
print_summary(opportunity, discovery_results, demo, poc, objection_results)
() -> Opportunity:
Opportunity(
opportunity_id=,
account_name=,
contact_name=,
stage=OpportunityStage.DISCOVERY,
value=,
probability=,
requirements=[
,
,
],
challenges=[
,
],
created_at=datetime.utcnow().isoformat(),
updated_at=datetime.utcnow().isoformat()
)
():
()
()
req_type, requirements results[].items():
()
()
()
():
()
()
()
()
()
()
()
():
()
()
()
()
()
()
()
()
():
()
()
objection results[]:
()
()
():
( + * )
()
( * )
()
()
()
()
()
()
()
()
() -> [, ]:
yaml
(filename, ) f:
yaml.safe_load(f)
():
run_sales_engineering()
__name__ == :
asyncio.run(main())
# BAD: No discovery
def bad_sales_engineering():
# No discovery
pass
# BAD: No demo
def bad_sales_engineering():
# No demo
support_discovery()
# BAD: No PoC
def bad_sales_engineering():
# No PoC
support_discovery()
create_demo()
# BAD: No objection handling
def bad_sales_engineering():
# No objection handling
support_discovery()
create_demo()
build_poc()
pip install pyyaml
# Copy example config
cp config/sales_engineering_config.yaml.example config/sales_engineering_config.yaml
# Edit configuration
vim config/sales_engineering_config.yaml
python sales_engineering/workflow.py
# View opportunities
cat sales_engineering/results/opportunities.json
# View demos
cat sales_engineering/results/demos/
# View PoCs
cat sales_engineering/results/pocs/
No Discovery
# BAD: No discovery
pass
No Demo
# BAD: No demo
support_discovery()
No PoC
# BAD: No PoC
support_discovery()
create_demo()
No Objection Handling
# BAD: No objection handling
support_discovery()
create_demo()
build_poc()
Support Discovery
# GOOD: Support discovery
engineer = SalesEngineer(config)
results = await engineer.support_discovery(opportunity)
Create Demo
# GOOD: Create demo
demo = await engineer.create_demo(opportunity)
Build PoC
# GOOD: Build PoC
poc = await engineer.build_poc(opportunity)
Handle Objections
# GOOD: Handle objections
support = SalesSupport(config)
results = await support.handle_objections(opportunity, objections)