Proveo sam ceo dan rastavljajući Claude Code-ov Skill Creator i otkrio da je ova stvar još moćnija nego što sam mislio

Poslednje vreme intenzivno radim sa Claude Code-ovim Skill sistemom i iskreno, što ga više koristim, sve više uviđam kako je smišljeno dizajniran. Ali kao programer, samo korišćenje nije dovoljno - moram da razumem kako radi ispod haube.

Zar ne?

Danas ćemo rastaviti create-skill Skill i videti šta se dešava od trenutka okidača do kraja izvršavanja. Preturio sam po izvornom kodu do poslednjeg detalja i raspleo ti redosled poziva funkcija.

Posle ovog teksta nećeš samo razumeti kako Skill sistem radi, nego ćeš moći i sam da napišeš kvalitetan Skill. Iskreno, ova veština u CV-u stvarno donosi poene.

01. Šta je zapravo Skill?

Pre nego što uđemo u izvorni kod, kratko ćemo proći osnove Skill koncepta.

Skill je mehanizam proširenja Claude Code-a - u suštini, direktorijum koji sadrži SKILL.md fajl i opcione resurse (scripts, references, assets). Može da pretvori Claude-a iz opšteg AI-a u stručnjaka za određenu oblast.

Na primer, kada instaliraš Skill za rad sa PDF-ovima, Claude može da ti spoji PDF-ove, izvuče tekst, popuni formulare. Kada instaliraš Skill za frontend razvoj, može da ti generiše React komponente u skladu sa normama tvog tima.

Standardna Skill struktura izgleda ovako:

skill-name/
├── SKILL.md          # obavezno, sadrži metapodatke i instrukcije
├── scripts/          # opciono, izvršni skriptovi
├── references/       # opciono, referentna dokumentacija
└── assets/           # opciono, šabloni, slike i drugi resursi

create-skill je pomalo specifičan - to je „meta Skill“, namenjen da ti pomogne da kreiraš nove Skill-ove.

Matrjoška, zar ne? Ali zaista dobro radi.

Ako bi svaki put kada pišeš Skill kretao od nule, koliko bi to tek bilo naporno. Sa ovim Skill-om, samo mu kažeš šta želiš i on ti generiše kompletan šablon.

02. Otkud sistem zna koji Skill da pozove?

Ovo je mehanizam u srcu Skill sistema i po meni najelegantniji deo dizajna.

Kada korisnik unese rečenicu, Claude Code skenira frontmatter svih Skill-ova, izdvaja name i description, pa procenjuje koji Skill najbolje odgovara korisnikovoj nameri. Obrati pažnju - ovde nije reč o prostom poklapanju ključnih reči, već sistem preko description-a razumeva stvarnu nameru korisnika.

create-skill frontmatter izgleda ovako:

---
name: create-skill
description: Guide for creating effective skills. This skill should be used when 
  users want to create a new skill (or update an existing skill)...
---

Ključni lanac poziva funkcija:

system_prompt_loader()
  └── extract_skill_metadata(skill_dir)  # izdvoji name + description
      └── smešta se u available_skills listu

match_skill(user_input, available_skills)
  └── poklapa nameru korisnika na osnovu description-a
      └── vraća odgovarajući skill_name: "create-skill"

Iskreno, ovaj dizajn je vrlo domišljen. Nije klasično poklapanje ključnih reči; sistem preko description-a razume nameru. Napišeš „napravi mi Skill za obradu PDF-a“ i sistem automatski nalazi create-skill, umesto glupo da matchuje reč „create“.

Okidači uključuju, između ostalog:

• „create a new skill“
• „write a skill“
• „skill structure“
• „how to make a skill“

Ovakvo semantičko razumevanje čini okidanje Skill-a prirodnijim. Ne moraš da pamtiš specifične komande - samo opisuješ potrebu kao u normalnom razgovoru i sistem shvata šta želiš.

03. Kako se SKILL.md učitava?

Kada poklapanje uspe, sistem čita SKILL.md odgovarajućeg Skill-a, parsira frontmatter da dobije metapodatke, a zatim ubacuje body sadržaj u kontekst. Proces deluje jednostavno, ali krije mnogo detalja vrednih pažnje.

Lanac poziva funkcija:

load_skill(skill_name)
  └── read_file(f"{skill_name}/SKILL.md")
      └── parse_frontmatter(content)
          ├── extract_yaml_frontmatter()  # izdvoji sadržaj između ---
          └── extract_markdown_body()      # izdvoji sadržaj posle ---
      └── inject_to_context(body_content)

U tom trenutku Claude-ov kontekst sadrži kompletne instrukcije create-skill-a, uključujući onih 6 koraka izvršavanja.

Obrati pažnju: sadržaj references i scripts još uvek nije učitan - oni se učitavaju po potrebi. Ovaj dizajn se zove „Progressive Disclosure“, o čemu smo već pisali.

Zašto ovakav dizajn?

Zato što je context window konačan. Ako bi kompletni sadržaj svih Skill-ova stalno stajao u kontekstu, brzo bi se prepunio. Uz Progressive Disclosure, sistem učitava samo ono što je trenutno potrebno - time se obezbeđuje potpunost funkcionalnosti bez rasipanja kontekstnog prostora.

04. Šest koraka u detaljima

SKILL.md kod create-skill-a definiše 6 standardnih koraka; idemo redom. Ovi koraci su vrlo smisleno složeni - od razumevanja potreba do konačnog pakovanja, čine zatvorenu petlju.

04-1. Understanding: prvo razjasni šta tačno želiš

Cilj ovog koraka je da izbegneš pravljenje Skill-a kog niko neće koristiti. Sistema će te pitati:

• „What functionality should the skill support?“
• „Can you give some examples?“
• „What would trigger this skill?“

Poziv funkcija:

step1_understanding()
  └── ask_user_questions([...])
      └── prikupi povratne informacije korisnika
          └── validate_examples(examples)

Iskreno, ovaj korak se lako preskoči, a zaista je bitan. Video sam mnogo ljudi koji odmah krenu da pišu kod, pa ispadne nešto što uopšte ne odgovara stvarnim potrebama. Ovim korakom osiguravaš da zaista razumeš šta korisnik želi, umesto da nagađaš.

Na primer, korisnik kaže „želim Skill za obradu Excel-a“ - tu treba potvrditi: koji tip Excel-a? Finansijski izveštaji ili analiza podataka? Koje operacije su potrebne? Čitanje, pisanje ili konverzija formata?

Tek kada razjasniš ova pitanja, možeš da napraviš zaista koristan Skill.

04-2. Planning: šta će ići u Skill

Ovaj korak apstrahuje konkretne korisničke potrebe u tipove resursa koji se mogu ponovo iskoristiti. To je deo procesa koji najviše iskušava iskustvo.

Lanac poziva funkcija:

step2_planning(user_examples)
  └── analyze_example(example)
  │   └── identify_reusable_resources(example)
  │       ├── need_script? → dodaj u scripts/ listu
  │       ├── need_reference? → dodaj u references/ listu
  │       └── need_asset? → dodaj u assets/ listu
  └── generate_resource_plan()

Na primer, za Skill koji obrađuje PDF, analizom može ispasti da ti trebaju:

• scripts/rotate_pdf.py - skripta za rotaciju PDF-a
• references/pdf_lib_docs.md - API dokumentacija PDF biblioteke
• assets/pdf_template/ - fajlovi PDF šablona

Ovaj proces planiranja je zapravo arhitektonski dizajn. Razmišljaš koje funkcije najbolje idu u skripte, šta treba referentnoj dokumentaciji, a šta resursima u vidu šablona. Dobar plan čini kasniju implementaciju mnogo lakšom.

04-3. Initializing: kreiranje fajlova kreće

Ovo je prvi korak koji zaista dira fajlove; poziva init_skill.py skriptu. Ta skripta ti generiše kompletan Skill šablon.

Lanac poziva funkcija:

step3_initialize(skill_name, output_path)
  └── run_script("scripts/init_skill.py", args=[...])
      └── init_skill.main()
          ├── validate_skill_name(skill_name)
          ├── skill_dir = Path(path) / skill_name
          ├── skill_dir.mkdir(parents=True)
          ├── generate_skill_md(skill_name)
          ├── generate_example_script()
          ├── generate_example_reference()
          └── generate_example_asset()

Pogledaj ključni deo init_skill.py:

def init_skill(skill_name, path):
    skill_dir = Path(path).resolve() / skill_name

    # Proveri da li direktorijum već postoji
    if skill_dir.exists():
        print(f"❌ Error: Skill directory already exists")
        return None

    # Kreiraj strukturu direktorijuma
    skill_dir.mkdir(parents=True, exist_ok=False)

    # Generiši SKILL.md iz šablona
    skill_content = SKILL_TEMPLATE.format(
        skill_name=skill_name,
        skill_title=title_case_skill_name(skill_name)
    )
    (skill_dir / 'SKILL.md').write_text(skill_content)

    # Kreiraj resursne direktorijume
    (skill_dir / 'scripts').mkdir()
    (skill_dir / 'references').mkdir()
    (skill_dir / 'assets').mkdir()

Skripta ti generiše kompletan šablon, uključujući TODO markere koji ti govore gde treba da popuniš. Iskustvo je zaista pažljivo osmišljeno. Ne krećeš od nule - samo modifikuješ šablon.

04-4. Editing: popunjavanje sadržaja

Ovaj korak je interaktivan i Claude te vodi kroz njega. To je najvremenski zahtevniji deo procesa i deo koji najviše odlučuje o kvalitetu Skill-a.

Poziv funkcija:

step4_edit_skill(skill_dir)
  ├── edit_scripts(skill_dir / "scripts")
  ├── edit_references(skill_dir / "references")
  ├── edit_assets(skill_dir / "assets")
  └── update_skill_md(skill_dir / "SKILL.md")

Nekoliko ključnih tačaka na koje treba obratiti pažnju:

• koristi infinitivni oblik (imperative/infinitive form)
• description mora da sadrži uslove okidača
• budi sažet - SKILL.md ne prelazi 500 linija

Pisanje SKILL.md je svojevrsna veština.

U ograničenom prostoru moraš jasno da izložiš funkcionalnost Skill-a, scenarije korišćenja i uslove okidača. description je posebno bitan jer određuje kada će Skill biti okinut.

Ako pišeš previše široko, desiće se lažna okidanja; ako pišeš previše usko, propustićeš stvarne scenarije upotrebe.

04-5. Packaging: pakovanje u format za distribuciju

Poziva package_skill.py skriptu koja Skill pakuje u .skill fajl. Ovo je poslednji korak objavljivanja Skill-a.

Lanac poziva funkcija:

step5_package(skill_dir, output_dir=None)
  └── run_script("scripts/package_skill.py", args=[...])
      └── package_skill.main()
          ├── validate_skill(skill_path)
          │   └── quick_validate.validate_skill()
          │       ├── check_skill_md_exists()
          │       ├── parse_frontmatter()
          │       ├── validate_name_format()
          │       └── validate_description_length()
          └── create_zip_file()

Ključna logika package_skill.py:

def package_skill(skill_path, output_dir=None):
    # Prvo validacija
    valid, message = validate_skill(skill_path)
    if not valid:
        print(f"❌ Validation failed: {message}")
        return None

    # Pakovanje u zip (.skill ekstenzija)
    skill_filename = output_path / f"{skill_name}.skill"
    with zipfile.ZipFile(skill_filename, 'w') as zipf:
        for file_path in skill_path.rglob('*'):
            if file_path.is_file():
                arcname = file_path.relative_to(skill_path.parent)
                zipf.write(file_path, arcname)

    return skill_filename

Obrati pažnju: pre pakovanja obavezno prolazi validaciju, čime se izbegava distribucija pokvarenog Skill-a. Kao CI provera pre commit-a - hvata problem u poslednjem trenutku.

04-6. Iteration: neprekidno usavršavanje

Opcioni korak - optimizacija Skill-a na osnovu stvarne upotrebe. Dobar Skill ne nastaje jednim pisanjem, već se usavršava tokom korišćenja.

step6_iterate(skill_dir)
  └── observe_usage_patterns()
      └── identify_improvements()
          └── update_skill_md_or_resources()

Možda otkriješ da neki scenariji nisu pokriveni ili da su neki opisi nejasni - tada je potrebna iterativna optimizacija. Cena iteracije Skill-a je niska jer je struktura jasna i izmene idu lako.

05. Tok validacije: tri kontrolne tačke čuvaju kvalitet

Validacija je ključna faza koja prožima ceo proces, a njom uglavnom rukuje quick_validate.py. Ta skripta je kao golman Skill-a - osigurava da samo ispravni Skill-ovi odlaze u pakovanje i distribuciju.

Detalji funkcije validacije:

def validate_skill(skill_path):
    # 1. Proveri da li SKILL.md postoji
    skill_md = skill_path / 'SKILL.md'
    if not skill_md.exists():
        return False, "SKILL.md not found"

    # 2. Izdvoji frontmatter
    content = skill_md.read_text()
    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
    frontmatter_text = match.group(1)

    # 3. Parsiraj YAML
    frontmatter = yaml.safe_load(frontmatter_text)

    # 4. Proveri obavezna polja
    if 'name' not in frontmatter:
        return False, "Missing 'name' in frontmatter"
    if 'description' not in frontmatter:
        return False, "Missing 'description' in frontmatter"

    # 5. Validiraj format imena (hyphen-case)
    name = frontmatter.get('name', '')
    if not re.match(r'^[a-z0-9-]+$', name):
        return False, f"Name '{name}' should be hyphen-case"

    # 6. Validiraj dužinu description-a
    description = frontmatter.get('description', '')
    if len(description) > 1024:
        return False, f"Description too long"

    return True, "Skill is valid!"

Validacija obuhvata:

• SKILL.md mora da postoji
• format frontmatter-a mora biti ispravan
• name mora biti u hyphen-case formatu
• description ne sme preći 1024 znaka
• ne sme sadržati specijalne znakove poput uglastih zagrada

Ova pravila deluju sitničavo, ali služe kvalitetu i doslednosti Skill-ova. Ako je ime Skill-a nepravilno ili je opis predug, to će ugroziti efikasnost okidača.

06. Dizajn u prvom planu: Progressive Disclosure

Najsuptilniji dizajn Skill sistema je „Progressive Disclosure“. Ta koncepcija prožima celu arhitekturu Skill sistema.

Nivo	Sadržaj	Veličina	Trenutak učitavanja
L1	Metadata (name + description)	~100 tokena	Uvek učitano
L2	SKILL.md body	<5k tokena	Nakon okidanja Skill-a
L3	Bundled resources	Neograničeno	Učitavanje po potrebi

Ovaj dizajn osigurava efikasno iskorišćenje context window-a. Ako bi kompletni sadržaj svih Skill-ova stalno stajao u kontekstu, brzo bi se prepunio. Uz Progressive Disclosure, sistem učitava samo ono što je trenutno potrebno - time se obezbeđuje potpunost funkcionalnosti bez rasipanja kontekstnog prostora.

Postoji još jedan dizajn, „stepenovanje slobode“:

• Visoka sloboda: čist tekstualni instrukcije (više ispravnih pristupa je moguće)
• Srednja sloboda: pseudokod ili skripte sa parametrima (postoji preporučeni obrazac ali su varijacije dozvoljene)
• Niska sloboda: specifične skripte, malo parametara (operacije su osetljive i zahtevaju doslednost)

To je kao da Claude-u ocrtavaš obim kretanja - ni previše stegnut, ni potpuno pušten nizu. Različiti zadaci zahtevaju različit stepen ograničenja, a ovaj dizajn omogućava Skill-u da se prilagodi raznim scenarijima.

07. Pregledan dijagram celog redosleda poziva

Jednim dijagramom sumiramo ceo tok izvršavanja:

Korisnički unos → procena okidača → učitavanje SKILL.md → 6 koraka izvršavanja → provera → pakovanje → kraj
    │           │            │              │           │       │
    │           │            │              │           │       └── .skill fajl
    │           │            │              │           └── validate_skill()
    │           │            │              └── step1() → step2() → ... → step6()
    │           │            └── inject_to_context()
    │           └── match_skill()
    └── "Napravi mi Skill"

Čitav tok je vrlo glatko osmišljen - od korisničkog unosa do konačnog ispisa, svaki korak ima jasnu svrhu i ishod. Koncepcija „eksplicitno složeno, implicitno jednostavno“ čini korisničko iskustvo vrlo tečnim.

07-1. Dublja analiza lanca poziva funkcija

Zaronimo dublje u konkretne pozive funkcija u svakoj fazi. To ti ne pomaže samo da razumeš kako sistem radi, već i da znaš gde da tražiš uzrok kad nešto krene naopako.

Kompletan lanac poziva u fazi okidača:

main_loop()
  └── process_user_input(user_input)
      └── load_all_skills_metadata()
      │   └── for skill_dir in skills_directories:
      │       └── extract_skill_metadata(skill_dir)
      │           ├── read_file(f"{skill_dir}/SKILL.md", limit=50)
      │           ├── parse_yaml_frontmatter(content)
      │           └── return {name, description}
      └── match_skill(user_input, available_skills)
          └── semantic_match(user_input, skill.description)
              └── calculate_similarity(user_input, description)
                  └── return best_match_skill_name

Kompletan lanac poziva u fazi učitavanja:

execute_skill(skill_name)
  └── load_skill_full(skill_name)
  │   ├── skill_path = find_skill_directory(skill_name)
  │   ├── skill_md = read_file(f"{skill_path}/SKILL.md")
  │   ├── frontmatter = parse_frontmatter(skill_md)
  │   ├── body = extract_markdown_body(skill_md)
  │   └── inject_to_context(body, priority="high")
  └── execute_skill_workflow(skill_name)
      └── follow_skill_instructions(body)

Ovde ima jedan detalj: priority parametar inject_to_context-a je postavljen na „high“, što znači da sadržaj Skill-a ima prednost nad opšte sistemske instrukcije. Time se osigurava da instrukcije Skill-a budu dovoljno ozbiljno shvaćene.

Kompletan lanac poziva u fazi izvršavanja:

follow_skill_instructions(skill_body)
  └── parse_workflow_steps(skill_body)
  │   └── extract_numbered_steps(body)
  │       └── return [step1, step2, step3, step4, step5, step6]
  └── for step in steps:
      └── execute_step(step)
          ├── identify_step_type(step)
          ├── load_required_resources(step)
          └── execute_step_logic(step)
              ├── if step.has_script:
              │   └── run_script(step.script_path, step.args)
              └── if step.requires_user_input:
                  └── ask_user(step.question)

Dobro ovakvog slojevitog dizajna je u tome što svaki sloj brine samo o svojoj odgovornosti, a slojevi komuniciraju preko jasnih interfejsa. Ako neki sloj zakaza, brzo možeš da lociraš konkretno mesto.

07-2. Mehanizam obrade grešaka

Obrada grešaka kod create-skill-a takođe je pažljivo osmišljena. Svaki korak ima svoju obradu:

Obrada grešaka u Step 3 (Initializing):

def step3_initialize(skill_name, output_path):
    try:
        result = run_script("scripts/init_skill.py", args=[skill_name, "--path", output_path])
        if result.returncode != 0:
            print(f"❌ Inicijalizacija nije uspela: {result.stderr}")
            return False
        return True
    except FileNotFoundError:
        print(f"❌ Ne mogu da pronađem init_skill.py skriptu")
        return False
    except PermissionError:
        print(f"❌ Nema dozvole za izvršavanje skripte")
        return False

Ovakva sitnozrnasta obrada grešaka omogućava korisniku da jasno vidi gde je problem, umesto da gleda maglovito „izvršavanje nije uspelo“.

07-3. Strategija učitavanja resursa

Skill sistem za učitavanje resursa koristi strategiju „lenjog učitavanja“. Resurs se ubacuje u kontekst tek kada zaista zatreba.

load_resource_on_demand(resource_path)
  ├── if resource_path in loaded_resources:
  │   └── return cached_content
  ├── content = read_file(resource_path)
  ├── validate_content(content)
  ├── loaded_resources[resource_path] = content
  └── inject_to_context(content, priority="medium")

Ova strategija donosi dve koristi: štedi kontekstni prostor i ubrzava učitavanje. Ako bi se odjednom učitali svi resursi, ne bi zauzeli samo mnogo prostora, već bi mnogi možda ostali neiskorišćeni.

08. Dublje u izvorni kod: detalji implementacije tri ključne skripte

Dosad smo govorili o toku; sada da zavirimo u konkretne implementacije tri ključne skripte. Ovaj kod sam izvukao iz instalacionog direktorijuma Claude Code-a - prvorazredni izvor.

08-1. init_skill.py: umetnost generisanja šablona

Ključni zadatak ove skripte je da generiše standardnu strukturu Skill direktorijuma. Ona ne pravi samo fascikle, već stvara i niz šablonskih fajlova.

Pogledaj kompletan sadržaj SKILL_TEMPLATE:

SKILL_TEMPLATE = """---
name: {skill_name}
description: [TODO: Complete and informative explanation of what the skill does and when to use it. Include WHEN to use this skill - specific scenarios, file types, or tasks that trigger it.]
---

# {skill_title}

## Overview

[TODO: 1-2 sentences explaining what this skill enables]

## Structuring This Skill

[TODO: Choose the structure that best fits this skill's purpose...]

## Resources

This skill includes example resource directories...
"""

Ovaj šablon je vrlo pažljivo osmišljen. Sadrži obavezni frontmatter, a na svakom mestu koje treba popuniti stoji TODO marker. Tako korisnik, nakon kreiranja Skill-a, jasno veli šta treba da izmeni.

08-2. package_skill.py: pakovanje i validacija u jednom

Filozofija ove skripte je „prvo validacija, pa pakovanje“. Poziva quick_validate.py da osigura kvalitet Skill-a - samo validan Skill ide u pakovanje.

Ovde je važan jedan detalj: pri pakovanju se koristi zipfile.ZIP_DEFLATED kompresija. To znači da je .skill fajl zapravo kompresovani zip, samo sa drugačijom ekstenzijom. Ovakav dizajn drži fajl malim i olakšava prenos i skladištenje.

with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
    for file_path in skill_path.rglob('*'):
        if file_path.is_file():
            arcname = file_path.relative_to(skill_path.parent)
            zipf.write(file_path, arcname)

08-3. quick_validate.py: šestostruka provera

Skripta za validaciju primenjuje šest slojeva provere, svaki sa jasnom svrhom:

1. Provera postojanja fajla: osigurava da SKILL.md postoji
2. Provera formata frontmatter-a: osigurava ispravne YAML razdvajače
3. Provera YAML parsiranja: osigurava da je frontmatter ispravan YAML
4. Provera obaveznih polja: osigurava prisustvo name i description
5. Provera normi imenovanja: osigurava da name prati hyphen-case
6. Provera ograničenja dužine: osigurava da description ne prelazi 1024 znaka

Ovakvo stepenasto podizanje provera otkriva razne probleme rano i sprečava pakovanje defektnih Skill-ova.

09. poređenje sa drugim AI alatima

Iskreno, Skill sistem je jedno od oružja Claude Code-a. GPT ima GPTs, Cursor ima Rules, ali Skill sistem Claude Code-a ima nekoliko jedinstvenih prednosti:

1. Progressive Disclosure: kompletan sadržaj se učitava tek nakon okidača, čime se štedi kontekst 2. Stepenovanje slobode: prema složenosti zadatka bira se stepen ograničenja 3. Mehanizam validacije: obavezna provera pre pakovanja čuva kvalitet 4. Izvršne skripte: podržava bundled scripts kojima se izvode determinističke operacije

Za poređenje, GPT-ovi GPTs su više okrenuti bazi znanja i prilagođavanju razgovora, Cursor-ovi Rules više ciljaju ograničenja kodnih normi, dok Skill Claude Code-a objedinjuje upravljanje kontekstom, domensko znanje i izvršne sposobnosti u jednu celinu.

Zato mnogi programeri koji koriste Claude Code govore da je Skill funkcija koja zaista menja radni tok.

10. Praktični saveti: kako napisati kvalitetan Skill

Toliko o teoriji - evo nekoliko praktičnih saveta:

1. description neka jasno navodi uslove okidača

To je ključno da bi Skill bio ispravno okinut. Ne piši ni previše široko ni previše usko. Tačno opiši koji problem Skill rešava i u kom scenariju treba da se koristi.

Na primer, dobar description izgleda ovako: „Use when working with PDF documents for: (1) Extracting text and tables, (2) Merging or splitting PDFs, (3) Filling form fields, (4) Converting to other formats“

2. Drži SKILL.md sažetim

Ne prelazi 500 linija. Ako je sadržaja previše, prebaci detalje u references, a u SKILL.md zadrži samo tok jezgra. Ne zaboravi - SKILL.md je vodič, a ne enciklopedija.

3. Piši više primera

Primeri koriste više od objašnjenja. U SKILL.md stavi više konkretnih primera da Claude zna kako da obradi razne situacije. Na primer, možeš napisati: „When user says 'merge these PDFs', use scripts/merge_pdf.py“

4. Testiraj svoj Skill

Pre objave, testiraj više puta. Proveri da li je okidač tačan i da li izvršavanje odgovara očekivanju. Dobar Skill zahteva više krugova doterivanja. Preporučujem da testiraš barem 5 različitih scenarija, kako bi se pokrile razne granične situacije.

5. Iskoristi references

Ako Skill obuhvata složeno domensko znanje - šemu baze, API dokumentaciju, poslovna pravila - stavi to u references direktorijum. Tako SKILL.md ostaje sažet, a detalji se učitavaju po potrebi.

11. Optimizacija performansi: tihi heroji Skill sistema

Mnogi možda nisu primetili da je Skill sistem uložio dosta truda u optimizaciju performansi. Te optimizacije čine izvršavanje Skill-a i brzim i efikasnim.

11-1. Mehanizam keširanja metapodataka

Sistem ne čita svaki put iznova metapodatke svih Skill-ova, već ih kešira:

# Pseudokod koji prikazuje mehanizam keširanja
class SkillMetadataCache:
    def __init__(self):
        self.cache = {}
        self.last_update = None

    def get_metadata(self, skill_name):
        if skill_name in self.cache:
            if not self.is_expired(skill_name):
                return self.cache[skill_name]

        # Keš promašaj ili isteklo, ponovo učitaj
        metadata = self.load_from_disk(skill_name)
        self.cache[skill_name] = metadata
        return metadata

    def is_expired(self, skill_name):
        # Proveri vreme modifikacije fajla
        file_mtime = os.path.getmtime(skill_path)
        return file_mtime > self.cache[skill_name].loaded_time

Ovaj mehanizam keširanja izbegava ponovljeno čitanje fajlova i znatno ubrzava odziv. Naročito dolazi do izražaja kada je broj Skill-ova veći.

11-2. Strategija inkrementalnog učitavanja

Za velike reference fajlove sistem primenjuje strategiju inkrementalnog učitavanja. Ne ubacuje čitav fajl odjednom u kontekst, već samo potrebni deo.

def load_reference_incremental(ref_path, section=None):
    if section:
        # Učitaj samo navedeni odeljak
        content = extract_section(ref_path, section)
    else:
        # Prvo učitaj sadržaj i pregled
        content = extract_toc_and_summary(ref_path)

    inject_to_context(content)

Ova strategija je naročito korisna za referentnu dokumentaciju od nekoliko stotina linija. Možeš prvo učitati sadržaj kako bi Claude znao strukturu dokumenta, a onda prema potrebi dopuniti konkretan sadržaj.

11-3. Predkompilacija skripti

Za Python skripte sistem proverava da li postoji predkompilirani bajtkod (.pyc fajl). Ako postoji i nije istekao, koristi bajtkod direktno i time preskače vreme kompilacije.

run_script("scripts/init_skill.py")
  ├── check_pyc_exists("scripts/init_skill.py")
  │   └── if exists and not expired:
  │       └── execute_pyc("scripts/__pycache__/init_skill.cpython-311.pyc")
  │   └── else:
  │       ├── compile_to_pyc("scripts/init_skill.py")
  │       └── execute_pyc(compiled_path)

Iako korisnik slabo oseća te optimizacije performansi, one osiguravaju glatko odvijanje Skill sistema. Dobar sistem baš treba da bude takav da korisnik i ne primeti njegovo prisustvo.

12. Sigurnosni mehanizmi: zaštitna mreža Skill sistema

Prilikom izvršavanja spoljnih skripti Skill sistem poseduje razrađen sigurnosni mehanizam. Time se osigurava da čak i Skill iz nepouzdanog izvora ne naškodi sistemu.

12-1. Izvršno okruženje u pesku

Skripte se izvršavaju u sandbox okruženju sa ograničenim dozvolama:

def run_script_in_sandbox(script_path, args):
    sandbox = Sandbox()
    sandbox.restrict_network_access()  # ograniči mrežni pristup
    sandbox.restrict_file_access(allowed_dirs=["./temp"])  # ograniči pristup fajlovima
    sandbox.restrict_system_calls()  # ograniči sistemske pozive

    result = sandbox.execute(script_path, args)
    return result

Ovaj sandbox mehanizam sprečava zlonamernu skriptu da ošteti sistem. Čak i ako skripta ima problem, radi se samo u ograničenom okruženju i ne može da dotakne osetljive resurse.

12-2. Validacija unosa

Sav korisnički unos koji se prosleđuje skripti prolazi strogu validaciju:

def validate_user_input(user_input):
    # Proveri da li sadrži opasne znakove
    dangerous_patterns = [';', '&&', '||', '`', '$(']
    for pattern in dangerous_patterns:
        if pattern in user_input:
            raise SecurityError(f"Input contains dangerous pattern: {pattern}")

    # Proveri dužinu
    if len(user_input) > 1000:
        raise SecurityError("Input too long")

    return sanitize_input(user_input)

Ova provera sprečava napade poput ubacivanja komandi. Korisnički unos se čisti, čime se osigurava da ne bude izvršen ili protumačen kao komanda.

12-3. Ograničenja upotrebe resursa

Prilikom izvršavanja skripte važe ograničenja upotrebe resursa, čime se sprečavaju napadi iscrpljivanjem:

script_limits = {
    "max_execution_time": 30,  # najviše 30 sekundi izvršavanja
    "max_memory_mb": 512,      # najviše 512MB memorije
    "max_file_size_mb": 100,   # najviše 100MB čitanja/pisanja
    "max_network_requests": 10 # najviše 10 mrežnih zahteva
}

Ovi sigurnosni mehanizmi omogućavaju Skill sistemu da istovremeno pruži snažnu funkcionalnost i zadrži sigurnost i stabilnost. Korisnik može slobodno da koristi razne Skill-ove bez brige o bezbednosti.

ending

Pošto sam rastavio tok izvršavanja create-skill-a, imam jedan snažan utisak.

Dobar dizajn alata nije u gomilanju sve više funkcija, već u tome da se složenost prepusti sistemu, a jednostavnost ostavi korisniku.

create-skill obuhvata 3 Python skripte, 6 glavnih koraka i desetine poziva funkcija, ali je korisničko iskustvo tečno i vođeno. Ne moraš da znaš šta se dešava iza kulisa - samo pratiš uputstva korak po korak i kreiraš ispravan Skill.

Koncepcija „eksplicitno složeno, implicitno jednostavno“ vredna je da je svaki programer nauči.

Takmičenje među AI programerskim alatima na kraju neće odlučivati ko ima više funkcija, već ko korisniku donosi manje brige. Skill sistem Claude Code-a ovde je zaista uložio napor.

[Vrednost tehnologije nije u tome koliko je složena, već u tome koliko životima čini jednostavnijim.]

Ako ti je ovaj sadržaj koristan, ne zaboravi lajk i podeli sa onima kojima treba.

Vidimo se u sledećem!