Preskoči na glavni sadržaj

Preko 35k zvezda, od nule ručno izgrađen Claude Code — ovaj open-source projekat mi digao adrenalin!

Chenmo Wang ErAIClaude CodeAgentopen-source projekat2238 reči7 minuta

Poslednjih dana jedan projekat kruži po GitHub-u.

learn-claude-code, 35k+ zvezda, 5.6k+ fork-ova — open-source tutorijal koji te uči da od nule sam izgradiš Claude Code.

Iskreno, kad sam video ovaj projekat, bio sam malo uzbuđen.

Toliko dugo koristim Claude Code i uvek sam se pitao kako on zapravo uspeva da "ti kažeš jednu rečenicu, a onda ti popravi kod, izvrši komande, ispravi bug-ove". Konačno neko to razlaže i to te podučava kako da implementiraš od nule.

Ključna ideja ovog projekta je jedna rečenica: The model is the agent. The code is the harness.

Laički: model je agent, kod je alatni sloj.

Šta to znači? Agent nije workflow koji nacrtaš, niti čvorovi koje prevučeš. Agent je taj istrenirani model sam po sebi. Kod koji pišeš samo mu obezbeđuje alate, znanje, dozvole i kontekst kao okruženje za rad.

Ovaj članak vodi kroz razradu projekta, šta on zaista nudi i da li vreme uloženo u njega vredi.

01. Šta projekat zaista uči

learn-claude-code je postepeni edukacioni projekat — od najosnovnije Agent petlje se sloj po sloj dodaju sposobnosti, dok ne implementira kompletnog Agenta poput Claude Codea.

Ukupno 12 sesija, koje odgovaraju 12 slojeva arhitekture:

Idem sloj po sloj:

s01: Agent petlja

Najosnovniji sloj. Model prima ulaz, generiše izlaz, zatim se ponavlja. Ovo je polazna tačka svakog Agenta — bez poziva alata, bez upravljanja kontekstom, prosta petlja razgovora.

s02: distribucija alata

Modelu se dodaju alati. Model generiše zahtev za poziv alata, sistem parsira i izvršava, a zatim vraća rezultat modelu. Ovo je ključni korak kojim Agent iz "četbota" postaje "neko ko ume da radi".

s03: upravljanje planom

Nauči model da planira. Ne kreće odmah na zadatak, već prvo formuliše plan, razlaže veliki zadatak na male i redom izvršava. Ovaj sloj rešava problem "kako razložiti složen zadatak".

s04: pod-Agent

Uvođenje pod-Agenata. Glavni Agent može delegirati specifičan zadatak pod-Agentu; pod-Agent ima nezavisan kontekst, a po završetku prijavljuje rezultat. Ovaj sloj rešava problem "podele posla".

s05: učitavanje veština po potrebi

Dinamičko učitavanje fajlova veština. Ne gura se svaki alat modelu, već se prema tipu zadatka učitavaju samo relevantne definicije veština. Ovaj sloj rešava problem "šta kad alata ima previše".

s06: kompresija konteksta

Kada istorija razgovora postane preduga, automatski se kompresuje. Ne radi se o prostom odsecanju, već o izdvajanju ključnih informacija i zadržavanju važnog konteksta. Ovaj sloj rešava problem "nedostatka tokena".

s07: graf zadataka

Zadaci se organizuju kao usmereni aciklički graf (DAG) sa podrškom za paralelno izvršenje. Ne moraju svi zadaci redom; neki mogu istovremeno. Ovaj sloj rešava problem "efikasnosti".

s08: pozadinski zadaci

Podrška za pozadinsko izvršenje dugih zadataka. Model može prvo da pokrene zadatak, a zatim nastavi sa drugim stvarima; kad zadatak završi, vraća se na rezultat. Ovaj sloj rešava problem "čekanja".

s09: timski rad

Više Agenata sarađuje. Svaki ima ulogu i odgovornost i koordinira se preko poruka. Ovaj sloj rešava problem "složenih sistema".

s10: protokol

Definiše komunikacioni protokol između Agenata. Ne šalju se poruke kako bilo, već po jedinstvenom formatu i semantici. Ovaj sloj rešava problem "standardizacije".

s11: samostalno preuzimanje

Agent može inicijativno da preuzme zadatak, umesto pasivno da čeka dodelu. Ovaj sloj rešava problem "inicijative".

s12: izolacija radnog stabla

Svaki zadatak ima nezavisan radni direktorijum, bez međusobnog ometanja. Ovaj sloj rešava problem "bezbednosti konkurentnosti".

Pošto prođeš ove 12 slojeva, shvatićeš zašto Claude Code može da "ti kažeš jednu rečenicu, a on popravi kod, izvrši komande i ispravi bug" — nije magija, već slojevito dodavanje sposobnosti.

02. Ključna ideja

Ono što me je najviše inspirisalo u ovom projektu nije konkretna implementacija koda, već koncept "Harness Engineering" koji uvodi.

Ranije smo u izgradnji AI aplikacija razmišljali: daću da dizajniram workflow, čvor A povežem sa čvorom B, čvor B sa čvorom C, pa neka model radi u svakom čvoru.

Ovaj projekat kaže: grešiš.

Agent je sam model. Model je već naučio kako da rasuđuje, planira i poziva alate. Tvoj posao nije da planiraš umesto njega, već da mu obezbediš dobro okruženje — alate, znanje, dozvole, kontekst.

Kao kada zaposliš veoma sposobnog radnika. Ne moraš mu reći svaki korak; tvoj posao je da mu opremiš računar, da mu otvoriš sistemske dozvole, da mu pripremiš dokumentaciju i podatke.

Zatim ga pustiš da sam radi.

Ovaj pomak shvatanja menja i zahteve prema inženjeru.

Ranije si morao da poznaješ orkestraciju workflow-a, dizajn čvorova i upravljanje stanjem. Sada moraš da znaš: kako dizajnirati upotrebljive alate, kako organizovati bazu znanja, kako upravljati granicama dozvola, kako optimizovati prenos konteksta.

Veštine su potpuno drugačije.

03. Test: od s01 do kraja

Praksa je važnija od teorije. Klonirao sam projekat i od s01 ga pokrenuo.

Preporučujem GitHub Desktop — veoma je zgodan.

Zatim da podelim prečicu za učenje open-source projekata: uđi u root direktorijum projekta i pokreni Claude Code.

Prompt: klonirao sam ovaj projekat, kako da od s01 idem kroz njega

Vidiš, Claude Code te vodi korak po korak, čak ti pomogne i da podesiš okruženje.

Po njegovim uputstvima, otvori .env fajl i ubaci API Key našeg modela. Ja sam ovde koristio Zhipu GLM-5.

Domaći model je za učenje open-source projekata sasvim dovoljan.

Zatim zamolismo Claude Code da prvo pređe preko zamki, pa krenemo po ispravnom toku.

A onda probamo u terminalu — OK, potvrđeno da može. Ostalo neću sve da prikazujem; obavezno probajte sami.

s01: osnovna Agent petlja

Kod s01 je vrlo jednostavan — samo while petlja:

import anthropic

client = anthropic.Anthropic()

while True:
    user_input = input("You: ")
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": user_input}]
    )
    print(f"Claude: {response.content[0].text}")

Bez alata, bez upravljanja kontekstom — prosta petlja razgovora. Pokreneš ga i to je običan četbot. Pitaš, on odgovara; pitaš ponovo, opet odgovara.

Ova petlja deluje prosto, ali definiše osnovni oblik Agenta: model je jezgro, kod je samo lepak.

s02: mehanizam distribucije alata

s02 postaje zanimljiv. Dodajemo poziv alata:

tools = [
    {
        "name": "read_file",
        "description": "Čita sadržaj fajla na zadatoj putanji",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Putanja fajla koji se čita"
                }
            },
            "required": ["path"]
        }
    },
    {
        "name": "write_file",
        "description": "Upisuje sadržaj u fajl na zadatoj putanji",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string"},
                "content": {"type": "string"}
            },
            "required": ["path", "content"]
        }
    }
]

Format definicije alata prati specifikaciju Anthropic-a, sa poljima name, description i input_schema. description je ključno — na osnovu tog opisa model odlučuje kada da pozove alat.

Pošto primi ulaz, model može izabrati da pozove alat. Sistem parsira zahtev, izvršava i vraća rezultat modelu:

def process_tool_call(tool_name, tool_input):
    if tool_name == "read_file":
        with open(tool_input["path"], "r") as f:
            return f.read()
    elif tool_name == "write_file":
        with open(tool_input["path"], "w") as f:
            f.write(tool_input["content"])
        return "File written successfully"
    else:
        return f"Unknown tool: {tool_name}"

# Obrada poziva alata u glavnoj petlji
if response.stop_reason == "tool_use":
    tool_use = next(block for block in response.content if block.type == "tool_use")
    tool_result = process_tool_call(tool_use.name, tool_use.input)
    # Vraćanje rezultata alata modelu radi dalje obrade

Jezgro ovog sloja je "distribucija alata": model odlučuje koji alat da pozove, a sistem izvršava i vraća rezultat. Model ne mora da zna kako je alat implementiran, dovoljno je da zna šta alat radi.

s03: upravljanje planom

s03 uvodi upravljanje planom. Model ne kreće odmah na zadatak, već prvo sastavlja plan:

PLAN_SYSTEM_PROMPT = """
Ti si asistent za planiranje zadataka. Primi korisnikov zadatak, prvo napravi plan izvršenja, razloži veliki zadatak na male korake.
Izlazni format:
1. Korak jedan: xxx
2. Korak dva: xxx
...
"""

def create_plan(task):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        system=PLAN_SYSTEM_PROMPT,
        messages=[{"role": "user", "content": task}]
    )
    return parse_plan(response.content[0].text)

def execute_plan(plan):
    for step in plan:
        result = execute_step(step)
        print(f"Izvrši: {step}")
        print(f"Rezultat: {result}")

Upravljanje planom rešava problem "kako razložiti složen zadatak". Na primer, korisnik kaže "preuredi ovaj projekat"; model prvo razlaže na: analiziraj strukturu projekta, identifikuj module koje treba preurediti, formuliši plan preuređenja, postepeno izvrši preuređenje.

s04: pod-Agent saradnja

U s04, uvođenjem pod-Agenata, čitav sistem dobija karakter "timskog rada":

class SubAgent:
    def __init__(self, name, system_prompt):
        self.name = name
        self.system_prompt = system_prompt
        self.context = []  # nezavisan kontekst

    def execute(self, task):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            system=self.system_prompt,
            messages=self.context + [{"role": "user", "content": task}]
        )
        self.context.append({"role": "user", "content": task})
        self.context.append({"role": "assistant", "content": response.content[0].text})
        return response.content[0].text

# Glavni Agent može delegirati zadatke pod-Agentu
code_reviewer = SubAgent("code_reviewer", "Ti si ekspert za code review...")
test_writer = SubAgent("test_writer", "Ti si ekspert za pisanje test case-ova...")

# Delegiranje zadataka
review_result = code_reviewer.execute("Pregledaj ovaj kod: " + code)
test_cases = test_writer.execute("Napiši testove za ovaj kod: " + code)

Pod-Agent ima nezavisan kontekst, a po završetku prijavljuje rezultat glavnom Agentu. Ovaj sloj rešava problem podele posla — različite vrste zadataka idu različitim pod-Agentima.

Kada prođeš kroz sve, najveći utisak je: svaki sloj koji dodaš rešava konkretan problem. Ne gomilamo funkcije, rešavamo bolne tačke.

Kontekst predug? Dodaj kompresiju. Zadatak previše kompleksan? Dodaj upravljanje planom. Treba paralelno? Dodaj graf zadataka. Čekanje previše traje? Dodaj pozadinske zadatke.

Svaki sloj ima jasno "problem-rešenje" mapiranje.

04. Zašto ovaj projekat vredi učenja

Iskreno, tutorijala o Agentima ima puno, ali su većina ili preplitka ili previše teorijska.

Ovaj projekat je drugačiji.

Prvo, ima kompletnu implementaciju koda.

Nema samo koncepte; svaki sloj ima prateći kod koji se može pokrenuti i menjati. Možeš izmeniti kod s01 u sopstvenog Agenta i zatim sloj po sloj dodavati sposobnosti.

Drugo, postepen je.

Ne dobijaš odmah kompletan sistem; ide se od najprostije petlje, sloj po sloj. Svaka promena je jasno vidljiva, kriva učenja je blaga.

Treće, ima Web vizuelnu platformu.

Uz projekat dolazi Web platforma za učenje; u browseru se može iskusiti efekat svakog sloja, bez kucanja komandi u terminalu.

Četvrto, ima višejezičnu dokumentaciju.

Engleski, kineski, japanski — dokumentacija je kompletna. Za developere koji govore kineski, čitanje je bez prepreka.

Peto, ideja je ispravna.

"The model is the agent. The code is the harness." — ova rečenica razjašnjava suštinu razvoja Agenata. Nije u pitanju crtanje workflow-a, niti prevlačenje čvorova, već izgradnja dobrog okruženja za rad.

05. Kako iskoristiti ovaj projekat na poslu

Šta dobijaš kada naučiš ovaj projekat?

Ne još jedan demo projekat, već kompletan metodološki okvir za razvoj Agenata.

Ako se baviš razvojem AI aplikacija, ovaj projekat će ti pomoći da razumeš osnovne principe Agenata. Kasnije, bez obzira na to koji framework koristiš — LangChain, Spring AI ili sopstveni — znaćeš šta svaki sloj rešava i zašto je potreban.

Ako radiš tehnički odabir, ovaj projekat ti pomaže da oceniš da li je Agent framework kompletan. Ima li kompresiju konteksta? Podržava li pod-agente? Može li graf zadataka paralelno? Jedan pogled i znaš.

Ako želiš sam da praviš točak, ovaj projekat je kompletna referentna implementacija. Od s01 do s12, svaki sloj ima kod koji se može direktno pozajmiti.

Nakon što sam ga ja završio, najveći dobitak je razumevanje "dizajna alata".

Ranije sam alate dizajnirao tako što bih napisao gomilu funkcija i bacio ih modelu. Sada znam da dizajn alata ima svoja pravila: opis mora biti jasan, parametri jednostavni, granice izričite, obrada grešaka kompletna.

Ti detalji direktno utiču na to da li model može dobro da iskoristi tvoj alat.

06. Predlozi za CV

Ako si prošao kroz ovaj projekat, pa čak i implementirao pojednostavljenu verziju Claude Codea, to iskustvo sasvim može u CV.

Naziv projekta: Mini Claude Code — postepeni Agent framework

Opis: na osnovu open-source projekta learn-claude-code, od nule implementiramo AI asistent za kodiranje nalik Claude Codeu, sa podrškom za poziv alata, upravljanje planom, pod-Agent saradnju, kompresiju konteksta i druge ključne sposobnosti.

Tehnički stack: Python, Anthropic API, FastAPI

Ključne odgovornosti:

  • Implementirana 12-slojna postepena Agent arhitektura, od osnovne petlje razgovora do kompletnog sistema za orkestraciju alata, sa oko 2000 linija koda
  • Dizajniran mehanizam distribucije alata, podržava dinamičko pozivanje sistemskih alata kao što su čitanje/pisanje fajlova i izvršavanje komandi, sa uspešnošću poziva alata 95%+
  • Implementiran model saradnje pod-Agenata, gde glavni Agent može delegirati specifične zadatke pod-Agentu, sa nezavisnom izolacijom konteksta
  • Dizajnirana strategija kompresije konteksta koja izdvajanjem ključnih informacija duge razgovore kompresuje za 60%, čime se smanjuje potrošnja tokena

Ovo iskustvo, na poziciji razvoja AI aplikacija, apsolutno donosi poene.

ending

Nakon što sam završio ovaj projekat, najveći utisak je: razvoj Agenata nije tako misteriozan kako deluje.

To nije neka duboka crna magija, već slojevito dodavanje sposobnosti. Od najprostije petlje razgovora kreneš — dodaš alate, dodaš plan, dodaš pod-agente, dodaš kompresiju; svaki sloj rešava konkretan problem.

Na kraju ispadne Agent poput Claude Codea, koji "ume da radi".

Ranije mi se činilo da je Claude Code magija, sada znam da je inženjerstvo.

Ranije sam mislio da je razvoj Agenata daleko od mene; sada znam da od s01, korak po korak, stižem do s12.

[Suština Agenta nije workflow, već model + alatni sloj. Model misli, alatni sloj izvršava.]

Ovaj pomak shvatanja je nadogradnja za svakoga ko želi da se bavi razvojem AI aplikacija.

Ako i ti želiš duboko da razumeš razvoj Agenata, ovaj projekat se zaista isplati proći. Ne samo da ga razumeš, već da ga pokreneš, izmeniš, pa čak i sam implementiraš.

GitHub: https://github.com/shareAI-lab/learn-claude-code

Za pitanja, vidimo se u komentarima, vidimo se u sledećem!