SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-11-14

Agent skills అంటే ఏమిటి? SKILL.md, MCP తేడా

Agent skill అనేది SKILL.md ఉన్న ఫోల్డర్. పని అవసరమైనప్పుడే సూచనలు లోడ్ అవుతాయి. భారీ prompt కంటే ఇది ఎందుకు మెరుగో, MCPతో తేడా ఏమిటో తెలుసుకోండి.

Agent skill అంటే వాస్తవంగా ఏమిటి

Agent skill అనేది డిస్క్‌లోని ఒక ఫోల్డర్. అందులో SKILL.md అనే ఫైల్ ఉంటుంది. ఆ ఫైల్‌లో పేరు, సంక్షిప్త వివరణ, సాధారణ Markdownలో రాసిన సూచనలు ఉంటాయి. Agent ప్రారంభమైనప్పుడు వివరణను లోడ్ చేస్తుంది. మీ అభ్యర్థన ఆ వివరణకు సరిపోలినప్పుడు లేదా మీరు skill పేరుతో దాన్ని invoke చేసినప్పుడు మాత్రమే సూచనలను చదువుతుంది. Skills‌కు సంబంధించిన దాదాపు ప్రతి విషయం ఈ రెండు వాక్యాల నుంచే అర్థమవుతుంది.

ఆ ఫోల్డర్‌లో ఆ ఒక్క ఫైల్‌కంటే ఎక్కువ ఉండవచ్చు. Agent Skills specification మూడు ఐచ్ఛిక directories‌ను పేర్కొంటుంది: Agent అమలు చేసే code కోసం scripts/, అవసరమైనప్పుడు Agent చదివే documents కోసం references/, templates మరియు data కోసం assets/. వీటిలో ఏదీ తప్పనిసరి కాదు. SKILL.md మాత్రమే ఉన్న ఫోల్డర్ కూడా పూర్తిస్థాయి skill.

restore-drill/
  SKILL.md
  references/retention-policy.md
  scripts/verify_snapshot.sh

చాలామంది తక్కువగా అంచనా వేసేది description. Agent skill‌ను తెరవాలా వద్దా అని నిర్ణయించుకునే ముందు చూసే ఏకైక text ఇదే. అందువల్ల skill ఏమి చేస్తుందో, ఎప్పుడు ఉపయోగించాలో, మనిషి వాస్తవంగా type చేసే పదాల్లోనే అది చెప్పాలి.

ఒక skill ఉపయోగించే వరకు దాని ఖర్చు దాదాపు ఎందుకు ఉండదు

ఈ ఫార్మాట్‌ను అర్థం చేసుకోవడం ఎందుకు ప్రయోజనకరమో చెప్పే ప్రధాన కారణం ఇదే. ఇది features గురించి కాదు, context గురించి. Loading దశలవారీగా జరుగుతుంది. Specification దీనిని progressive disclosure అని పిలుస్తుంది.

Startup సమయంలో agent ప్రతి installed skill యొక్క name మరియు description ను మాత్రమే load చేస్తుంది. మిగతా ఏదీ load చేయదు. Agent Skills specification ప్రకారం, ఒక్క skill‌కు సుమారు 100 tokens పడతాయి (October 2026 నాటికి ప్రచురించిన guidance). పన్నెండు skills install చేస్తే, ఒక పొడవైన paragraph‌కు సరిపడే context మాత్రమే ఖర్చవుతుంది.

ఒక request description‌కు సరిపోతే, agent ఆ ఒక్క SKILL.md యొక్క bodyని చదువుతుంది. Bodyని 5,000 tokens కంటే తక్కువగా, fileని 500 lines కంటే తక్కువగా ఉంచాలని specification సూచిస్తుంది. ఈ దశలో references/ మరియు scripts/ లోని filesకు ఇంకా ఎలాంటి ఖర్చు ఉండదు. Instructions agentను అక్కడికి పంపితేనే reference file load అవుతుంది. Bundled script మాత్రం మరో విధంగా పనిచేస్తుంది: agent దాన్ని shell ద్వారా run చేస్తుంది. అందువల్ల script source context windowలోకి రాదు. దాని output మాత్రమే contextలోకి వస్తుంది.

దీనితో ప్రజలు మొదట ఆశ్రయించే విధానాన్ని పోల్చండి: ఒక భారీ prompt. System promptలో లేదా ఎప్పుడూ అమలులో ఉండే instructions fileలోని ప్రతి lineకు ప్రతి requestలో, ప్రతి sessionలో ఖర్చు ఉంటుంది. Taskకు అది అవసరమా కాదా అన్నది ముఖ్యం కాదు. అది actual questionతో శ్రద్ధ కోసం పోటీ పడుతుంది. Standing instructionsగా 10,000 tokens ఉంటే, సమయం ఎంత అని మాత్రమే అడిగినా ఆ ఖర్చు చెల్లించాలి. Activationకు ముందు పన్నెండు skillsకు సుమారు 1,200 tokens పడతాయి. అయితే load చేసిన instructions అదే conversationలోని తరువాతి tasks కోసం contextలో కొనసాగవచ్చు. Skillsకు అనుకూలంగా ఉన్న పూర్తి కారణం ఇదే. అందుకే చిన్న library, పొడవైన prompt కంటే మెరుగ్గా పనిచేస్తుంది.

ఒక ముఖ్యమైన పరిమితి ఉంది. Claude Codeలో skill ఒకసారి load అయిన తర్వాత, దాని body తరువాతి turnsలో కూడా conversationలో ఉంటుంది. అందువల్ల పొడవైన SKILL.md ఒక్కసారి మాత్రమే వచ్చే ఖర్చు కాదు; మళ్లీ మళ్లీ వచ్చే ఖర్చు. Compaction load చేసిన skill contentను కుదించవచ్చు లేదా తొలగించవచ్చు. వివరాలను references/ లోకి తరలించడం కేవలం చక్కదనం కోసం కాదు. System ఉద్దేశించిన విధంగా పనిచేసే విధానం అదే.

Agent skill అనేది tool call కాదు

Tool అని కూడా పిలిచే function call అనేది model invoke చేయగల అంశం. Harness model కు name, description, arguments ఆకృతి ఉన్న schema ను పంపుతుంది. Model call ను ఉత్పత్తి చేస్తుంది, మీ code దాన్ని అమలు చేస్తుంది, తరువాత ఫలితం message గా తిరిగి వస్తుంది. Tools పనులు చేస్తాయి. ఈ exchange లోని రెండు భాగాలు model చుట్టూ loop ను నడిపే ప్రోగ్రామ్ అయిన harness కు చెందినవి. Startup సమయంలో మీ skill descriptions ను చదివి, skill ను ఎప్పుడు తెరవాలో నిర్ణయించేది కూడా అదే.

Skill స్వయంగా ఏదీ execute చేయదు. Agent దాన్ని చదివి, తనకు ఇప్పటికే ఉన్న tools ను ఉపయోగించి చర్య తీసుకుంటుంది. Skill invoke చేసినప్పుడు Claude Code arguments ను స్వీకరించి, $ARGUMENTS వంటి placeholders ద్వారా వాటిని తన instructions లో చేర్చుతుంది. ఏ tools ను ఏ క్రమంలో ఉపయోగించాలి, తరువాత ఏమి తనిఖీ చేయాలి అనే విషయాలను model కు చెప్పడమే skill చేయగల పని. రెండవ agent కు పని అప్పగించడం దీనికి స్పష్టమైన ఉదాహరణ: ఒక Claude Code session ఇప్పటికే మరొక session కు message పంపగలదు, దీనిని ఎప్పుడు చేయడం సముచితం, ఏమి పంపాలి అనే విషయాలను మీరు skill లో రాస్తారు.

సంక్షిప్తంగా చెప్పాలంటే: tool agent కు కొత్త సామర్థ్యాన్ని ఇస్తుంది. Skill ప్రధానంగా agent కు ఇప్పటికే ఉన్న సామర్థ్యాలను ఎలా ఉపయోగించాలో నిర్ణయించే విచక్షణను ఇస్తుంది. Skill కొత్త సామర్థ్యాన్ని జోడించినప్పుడు కూడా, agent తనకు ఇప్పటికే ఉన్న shell తో run చేసే bundled script ద్వారా దాన్ని చేస్తుంది. ప్రతి సారి ఖచ్చితమైన, validation చేసిన ఫలితాన్ని ఉత్పత్తి చేయాల్సిన step అయితే tool లేదా script కావాలి. ఒకే విధమైన ఆలోచనను స్థిరంగా వర్తింపజేయాల్సిన step అయితే skill కావాలి. చేసే మార్పు పనిచేసేంత చిన్నదిగా ఉండేలా coding agent ను ప్రేరేపించే Ponytail చూపినట్లు, skill కేవలం judgment మాత్రమే అయి ఉండవచ్చు, అయినా మీరు ఎక్కువగా ఉపయోగించేది అదే కావచ్చు: అది కొత్త capability ఏదీ జోడించదు; agent ఇప్పటికే ఉన్న capabilities ను ఎలా ఉపయోగిస్తుందో మాత్రమే మారుస్తుంది. ఆ judgment దానికి విరుద్ధమైన దిశలో కూడా ఉండవచ్చు. Depth Tree ద్వారా agent పనిని ముందుగానే పూర్తయిందని ప్రకటించకుండా చేసే unlazy skill restraint కంటే thoroughness పై దృష్టి పెట్టే అదే విధానానికి ఉదాహరణ.

Agent skill ఒక MCP server కాదు

MCP (model context protocol) అనేది agent ను బాహ్య వ్యవస్థకు అనుసంధానించే protocol. MCP server అనేది ఆ protocol ను అమలు చేసి, agent కు tools అందించే process. దీనికి సాధారణంగా configuration, credentials, అలాగే local command లేదా network endpoint అవసరం. Skill అనేది markdown file ఉన్న ఒక folder. ఇందులో process, port లేదా protocol ఏదీ ఉండదు.

Context cost కూడా ఇదే విధంగా భిన్నంగా ఉంటుంది. MCP server అందించే ప్రతి tool కు name, description, argument schema ఉంటాయి. వాటిని ముందుగానే load చేసే client లో, ఉపయోగించినా ఉపయోగించకపోయినా, అవి మొత్తం session వ్యవధిలో request లో ఉంటాయి. Claude Code ఇప్పుడు డిఫాల్ట్‌గా ఈ విధంగా పనిచేయదు: October 2026 నాటికి దాని tool search ముందుగానే enabled గా ఉంటుంది. అందువల్ల session ప్రారంభంలో tool names మరియు server instructions మాత్రమే load అవుతాయి. Claude వాటి కోసం search చేసినప్పుడు full definitions వస్తాయి. ఉపయోగించకుండా ఉన్న skill లో ఒక line text మాత్రమే ఉంటుంది.

ఈ రెండూ పరస్పర పూరకాలు. అత్యుత్తమ setup లు రెండింటినీ ఉపయోగిస్తాయి. MCP server access అందిస్తుంది. Skill procedure ను అందిస్తుంది: మీ team యొక్క వాస్తవ workflow కోసం ఏ tools ను call చేయాలి, ఏ క్రమంలో చేయాలి, మంచి result ఎలా ఉండాలి. మీరు స్వయంగా host చేస్తే, VPS పై MCP servers నడపడం ఆ భాగాన్ని వివరిస్తుంది.

An agent skill అనేది system prompt లేదా AGENTS.md కాదు

ఇవి రెండూ markdownలోని సూచనలే కాబట్టి ఈ గందరగోళం సహజమే. తేడా అవి ఎప్పుడు load అవుతాయనేదిలో ఉంది. ప్రారంభంలో load అయ్యే system prompt మరియు project instructions ఎల్లప్పుడూ అమలులో ఉంటాయి; agent వాటి directoriesలో పనిచేసినప్పుడు nested AGENTS.md మరియు CLAUDE.md files load అవుతాయి. Skill అవసరమైనప్పుడు మాత్రమే load అవుతుంది. Claude Code యొక్క output styles ఎల్లప్పుడూ అమలులో ఉండే స్థాయిలో ఉంటాయి; ఒకదాన్ని ఎంచుకుంటే system prompt నే సవరించబడుతుంది, అందువల్ల sessionలోని ప్రతి reply పై అవి ప్రభావం చూపుతాయి; ఏ skill‌కు సంబంధం లేని replies పై కూడా.

పరీక్షించాల్సింది ఒక్క ప్రశ్న: ఈ paragraph‌ను పట్టించుకోకుండా వదిలేస్తే, దీనితో ఎలాంటి సంబంధం లేని taskలో అది తప్పు అవుతుందా? House style, build command, branch naming rule ప్రతి taskకు వర్తిస్తాయి. కాబట్టి అవి always-on fileలో ఉండాలి; ప్రతి సారి load కావడమే వాటి ఉద్దేశం. నెలకు రెండుసార్లు అమలు చేసే release checklist ప్రతి taskకు వర్తించదు. కాబట్టి అది skillలో ఉండాలి. మీ always-on fileలోని ఏదైనా section numbered procedureగా పెరిగితే, దాన్ని తరలించాల్సిన సమయం వచ్చిందని అర్థం.

ఆ filesకు కూడా సరిగ్గా పాటించాల్సిన స్వంత conventions ఉంటాయి. మేము ఉపయోగించే రెండు మార్గాల కోసం AGENTS.mdలో ఏమి ఉండాలి, human fileలో ఏమి ఉండాలి మరియు codebase నిర్మాణాన్ని వివరించే design.md చూడండి.

కనిష్ఠ skill ఎలా ఉంటుంది

Claude Code లో వ్యక్తిగత skills ~/.claude/skills/<name>/SKILL.md లో ఉంటాయి. అవి ఆ యంత్రంలోని మీ అన్ని projects కు వర్తిస్తాయి. అయితే Cowork లేదా cloud sessions కు వర్తించవు. Project skills .claude/skills/<name>/SKILL.md లో ఉంటాయి. అవి git కు commit అవుతాయి కాబట్టి మీ బృందానికి కూడా అందుబాటులో ఉంటాయి. Claude project లోని cloud threads వాటిని load చేయవు. GitHub Copilot మరియు VS Code project skills ను .github/skills/, .agents/skills/, అలాగే .claude/skills/ నుంచి చదువుతాయి. లోపల ఉన్న file ఒక్కటే.

mkdir -p ~/.claude/skills/restore-drill
---
name: restore-drill
description: Run a restic restore drill and report what was recovered. Use when the user asks to test backups, verify a restore, or check that a snapshot is readable.
---

# Restore drill

1. Run `restic snapshots` and pick the newest snapshot for the host in question.
2. Restore it into a scratch directory under `/tmp`, never over live data.
3. Compare the restored file count and total size against the snapshot summary.
4. Report the snapshot ID and anything that failed to restore.

If `restic snapshots` reports that it cannot open the config file, stop and report the full error instead of guessing the cause.

ఇది పూర్తి skill. మీరు టైప్ చేసే command ను directory name నిర్ణయిస్తుంది. కాబట్టి ఇది /restore-drill. Claude Code లో /skills menu install చేసిన వాటిని చూపిస్తుంది. File సరిగ్గా గుర్తించబడిందో త్వరగా నిర్ధారించడానికి ఇది సులభమైన మార్గం. అది ఆ menu లో కనిపించకపోతే ముందుగా పేర్లను తనిఖీ చేయండి. File పేరు SKILL.md అయి ఉండాలి. Agent Skills specification ప్రకారం name లో lowercase letters, digits మరియు single hyphens మాత్రమే ఉండాలి. అదీ directory name తో సరిపోవాలి. మీ agent మళ్లీ అమలు చేయగల procedure గా ఇదే విధానాన్ని రాయడం VPSలో scheduled restic backups కు సహజమైన అనుబంధం. ఎందుకంటే backup నడవడం, backup restore చేయడం ఒకటే కాదు.

స్క్రిప్ట్‌గా ఉండాల్సిన skill ఎప్పుడు?

ప్రతిసారీ ఒకే సరైన సమాధానం ఉండే ఏ దశనైనా script‌గా రాయాలి. ఆ skill‌లో ఎప్పుడు దాన్ని run చేయాలి, output‌ను ఎలా చదవాలి అనే విషయాలను చెప్పే కొన్ని పంక్తులు మాత్రమే ఉంచాలి. దీనికి రెండు కారణాలు ఉన్నాయి. రెండూ ఆచరణాత్మకమైనవే.

మొదటిది, script source context window‌లోకి ఎప్పుడూ రాదు. 300 పంక్తుల parser‌కు దాని output మాత్రమే context‌లోకి వస్తుంది. అదే logic‌ను markdown సూచనలుగా రాస్తే, skill load అయిన ప్రతిసారీ దాని పూర్తి పొడవు context‌లోకి వస్తుంది.

రెండవది, script రెండుసార్లు run చేసినా ఒకే సమాధానం ఇస్తుంది. ప్రతి run‌లో అదే log parsing నియమాన్ని మళ్లీ రూపొందించమని model‌ను అడిగితే, పొరపాటు జరిగే సందర్భంలో అది స్వల్పంగా భిన్నంగా మారవచ్చు. రెండు సంఖ్యలు సరిపోకపోయే వరకు ఈ విషయం మీకు తెలియకపోవచ్చు.

కాబట్టి పనిని దాని స్వభావం ఆధారంగా విభజించండి. “CSV‌ను parse చేసి, total line items‌తో సరిపోని ప్రతి row‌ను print చేయి” అనేది script. “script print చేసిన rows‌ను పరిశీలించి, వాటిలో ఏవి data entry పొరపాటులా కనిపిస్తున్నాయో వివరించు” అనేది skill instruction. నిర్ణయాధారిత పనిని markdown‌లో, deterministic పనిని code‌లో ఉంచడం, agent‌ను మీరు గమనించకపోయినా run చేయగల loop‌ను నిర్మించడం వంటి అదే క్రమశిక్షణ.

నా skill ఎందుకు ఎప్పుడూ trigger కావడం లేదు?

ఎందుకంటే దాని description skill ఏమి చేస్తుందో మాత్రమే చెబుతోంది; దాన్ని ఎప్పుడు ఉపయోగించాలో చెప్పడం లేదు. మీ అభ్యర్థనతో agent సరిపోల్చాల్సింది ఆ ఒక్క పంక్తినే. "డేటాబేస్ పనిలో సహాయపడుతుంది" అనే వివరణ ప్రత్యేకంగా దేనితోనూ సరిపోలదు. "staging database పై schema migration నడుపుతుంది. table migrate చేయమని, column జోడించమని లేదా schema మార్చమని user అడిగినప్పుడు ఉపయోగించండి" అనే వివరణలో వ్యక్తి వాస్తవంగా టైప్ చేసే పదాలు ఉంటాయి. అందువల్ల అది trigger అవుతుంది.

దీనికి విరుద్ధమైన సమస్య ఎప్పుడూ trigger అయ్యే skill. "ఈ repository లో ఏ code మార్పుకైనా ఉపయోగించండి" వంటి వివరణ ప్రతిదానితోనూ సరిపోతుంది. అందువల్ల body ప్రతి task లోనూ load అయి, తరువాతి turns లో కూడా conversation లో కొనసాగుతుంది. మీరు ఉద్దేశించిన సందర్భానికి మాత్రమే సరిపోయేలా వివరణను పరిమితం చేయండి. Claude Code లో frontmatter లో disable-model-invocation: true ను కూడా సెట్ చేయవచ్చు. దీంతో automatic loading ఆగిపోతుంది, కానీ మీరు దాని పేరును టైప్ చేసినప్పుడు skill అందుబాటులో ఉంటుంది.

మూడవ సమస్య tool ను నకలు చేసే skill. MCP server ఇప్పటికే అందించే API పై agent కు curl చేయమని సూచించడం, లేదా harness లో search tool ఉన్నప్పటికీ files లో grep చేయమని చెప్పడం, నెమ్మదైన మార్గాన్ని సృష్టిస్తుంది. అదనంగా పరస్పరం విభేదించే రెండు sets of instructions ఏర్పడతాయి. నకలును తొలగించి, దాని ఉద్దేశాన్ని మాత్రమే వివరించండి.

ఈ మూడింటిలో మీ సమస్య ఏదో ఊహించవద్దు. కొత్త session లో అదే prompt ను రెండుసార్లు run చేయండి. ఒకసారి skill అందుబాటులో ఉండేలా, మరోసారి దాన్ని switch off చేసి run చేయండి. తరువాత రెండు answers ను పోల్చండి. కొత్త session ముఖ్యమైనది. ఎందుకంటే skill రాసిన session లో skill చెప్పే ప్రతిదీ ఇప్పటికే ఉంటుంది. దాంతో రాసిన version లోని లోపాలు కనిపించకుండా పోతాయి. Anthropic యొక్క skill-creator plugin ఈ పోలికను Claude Code లో automatic గా చేస్తుంది. ఏ prompts skill ను trigger చేయాలో, ఏవి trigger చేయకూడదో కూడా ఇది generate చేస్తుంది. ప్రతి prompt ఎంత తరచుగా trigger అవుతుందో కూడా కొలుస్తుంది. Skill load అయినప్పటికీ agent దాని సూచనల ప్రకారం పని చేయకపోతే, సమస్య description లో లేదు. ఇప్పటికే చదివిన instructions ను agent ఎందుకు పట్టించుకోదో వివరించే కారణాలు తర్వాత పరిశీలించాల్సిన అంశం.

ఇది ఒక vendor‌కు చెందిన formatనా, లేక standardనా?

Anthropic ఈ format‌ను 2025 చివర్లో ప్రచురించింది. తరువాత agentskills.io వద్ద hosted open standard‌గా విడుదల చేసింది. 2026 October 22న, Linux Foundation ఆధ్వర్యంలోని Agentic AI Foundation‌కు Agent Skills‌ను విరాళంగా అందిస్తున్నట్లు Anthropic ప్రకటించింది. 2026 October నాటికి, ఆ specification తప్పనిసరి name మరియు description fields, ఐచ్ఛిక license, compatibility, metadata మరియు allowed-tools fields, మూడు ఐచ్ఛిక directories, అలాగే staged loading behaviour‌ను నిర్వచిస్తుంది. దీనితో పాటు reference validator కూడా అందిస్తుంది. అందువల్ల share చేయడానికి ముందు skills-ref validate ./my-skill ఒక folder‌ను spec‌కు అనుగుణంగా ఉందో లేదో తనిఖీ చేస్తుంది.

Client listే అసలు సూచన. అదే folder‌ను Claude Code, Cursor, OpenAI Codex, Gemini CLI, GitHub Copilot, VS Code, Goose, OpenHands మరియు opencode వంటి అనేక clientలు చదువుతాయి. Microsoft తన skills‌ను ఈ format‌లో github.com/microsoft/skills వద్ద ప్రచురిస్తుంది. అలాగే Skill Recorder అనే desktop tool‌ను కూడా అందిస్తుంది. ఇది మీరు ఒక task‌ను ఒక్కసారి చేయడాన్ని గమనించి, దాన్ని ఒక intent మరియు క్రమబద్ధమైన steps‌గా పునర్నిర్మించి, ఫలితాన్ని skill‌గా రాస్తుంది. ఒక vendor రూపొందించిన recorder output format మరొకరి specification‌కు చెందినదిగా ఉండటం, ఆ format ఇక ఒకే product feature‌గా మిగలలేదని సూచిస్తుంది.

మొదట ఏమి రాయాలి

లైబ్రరీని ముందుగానే ప్రణాళిక చేయవద్దు. ఒకే సూచనలను chatలో మూడోసారి paste చేస్తున్నట్టు మీరే గుర్తించిన తర్వాత ఆ పాఠ్యాన్ని SKILL.md లోకి తరలించి, paste చేసిన భాగాన్ని తొలగించండి. మీరు ఇప్పటికే అనుభవించిన పునరావృతమే ఉంచదగిన skillకు నమ్మదగిన ఏకైక trigger. Search procedure మొదటి skillగా అనుకూలంగా ఉంటుంది. మీ స్వంత SearXNG instance ఆధారంగా రూపొందించిన search skill దీనికి రూపాన్ని చూపిస్తుంది.

రెండు అలవాట్లు libraryను సక్రమంగా ఉంచుతాయి. మీరు రాయకపోయిన ప్రతి skillను install చేయడానికి ముందు చదవండి. ఇందులో scripts కూడా ఉన్నాయి. Skill అంటే మీ agent అనుసరించే సూచనలు, అలాగే అది అమలు చేయగల code. అందువల్ల దాన్ని అపరిచితుడి softwareను install చేసినట్టుగా పరిగణించండి. Credentialsను folder వెలుపల ఉంచండి. ఎందుకంటే skill commit చేసి share చేసే text file. మీ agentsకు secretsను దూరంగా ఉంచడం ఆ విలువలను బదులుగా ఎక్కడ ఉంచాలో వివరిస్తుంది. ఈ సంవత్సరం agentsను నేర్చుకునే road map setupలోని మిగతా భాగాలతో skillsను ఏ క్రమంలో అమర్చాలో చూపిస్తుంది.

FAQ

agent skill మరియు MCP server మధ్య తేడా ఏమిటి?

MCP (model context protocol) server అనేది protocol ద్వారా agent కు tools అందించే running process. అందువల్ల దీనికి configuration మరియు credentials అవసరం. Client వాటి definitions ను deferred loading చేయకపోతే, అన్ని tool definitions మొత్తం session అంతా context ను ఆక్రమిస్తాయి. Claude Code ఇప్పుడు default గా వాటిని deferred loading చేస్తుంది. agent skill అనేది SKILL.md file ను కలిగి ఉన్న folder. ఇందులో process లేదా protocol ఉండదు. Agent దాన్ని చదవాలని నిర్ణయించుకునే వరకు దీనికి సుమారు 100 tokens మాత్రమే ఖర్చవుతాయి. Agent కు system access ఇవ్వడానికి MCP server ను ఉపయోగించండి. ఆ access ను సమర్థంగా ఉపయోగించే విధానాన్ని agent కు చెప్పడానికి skill ను ఉపయోగించండి. అనేక setup లలో రెండింటినీ ఉపయోగిస్తారు.

agent skills కేవలం Claude Code తో మాత్రమే పనిచేస్తాయా?

లేదు. Anthropic ఈ format ను అభివృద్ధి చేసి, తరువాత agentskills.io వద్ద open standard గా విడుదల చేసింది. అదే folder ను Cursor, OpenAI Codex, Gemini CLI, GitHub Copilot, VS Code, Goose, OpenHands మరియు ఇతర clients కూడా చదువుతాయి. ప్రతి client ఎక్కడ వెతుకుతుంది, ఏ అదనపు frontmatter fields ను అర్థం చేసుకుంటుంది అనే విషయాల్లో తేడా ఉంటుంది. Claude Code ~/.claude/skills/ మరియు .claude/skills/ ను చదువుతుంది. GitHub Copilot మరియు VS Code repository లోని .github/skills/, .claude/skills/ లేదా .agents/skills/ ను చదువుతాయి. SKILL.md file మాత్రం మార్పు లేకుండా వాటి మధ్య తరలించవచ్చు.

పనితీరు తగ్గే ముందు ఎన్ని skills install చేయవచ్చు?

పరిమితి సంఖ్య కంటే startup budget పై ఆధారపడి ఉంటుంది. ప్రతి installed skill specification లోని ప్రచురిత guidance ప్రకారం దాని name మరియు description ను అందిస్తుంది. వీటికి సుమారు 100 tokens ఖర్చవుతాయి. అందువల్ల skills ఉపయోగించకముందే 30 skills కు సుమారు 3,000 tokens ఖర్చవుతాయి. మొదట ప్రభావితం అయ్యేది speed కాదు, matching. ఒకదానితో మరొకటి overlap అయ్యే descriptions ఉన్న అనేక skills వల్ల model సరైన skill ను ఎంచుకోవడం కష్టమవుతుంది. Overlap లేని descriptions రాయండి. ఉపయోగించడం ఆపేసిన skills ను తొలగించండి.

ఈ instruction ను skill లో ఉంచాలా, లేక AGENTS.md లో ఉంచాలా?

ఇది repository లోని ప్రతి task కు వర్తిస్తుందా అని ఆలోచించండి. Build commands, house style మరియు naming rules అన్నీ tasks కు వర్తిస్తాయి. కాబట్టి అవి always-on file లో ఉండాలి. ప్రతి సారి load చేయడమే దాని ఉద్దేశం. Release checklist లేదా restore drill వంటి అప్పుడప్పుడు మాత్రమే అమలు చేసే procedure skill గా ఉండాలి. Activation కు ముందు దాని one-line description కు మాత్రమే ఖర్చవుతుంది. Claude Code లో load చేసిన తర్వాత, సంబంధం లేని tasks అయినా తరువాతి turns అంతటా దాని instructions conversation లో కొనసాగుతాయి. Numbered steps గా పెరిగిన AGENTS.md section సాధారణంగా తరలించాల్సిన skill అయి ఉంటుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?