Frameworki AI

jarekr000000
  • Rejestracja: dni
  • Ostatnio: dni
  • Lokalizacja: U krasnoludów - pod górą
  • Postów: 4727
4

Zbieram tutaj jakieś doświadczenia z frameworkami AI.
Czyli jak pracujecie z Klaudiuszem

Jak wrzucacie zadania?
Jak kontrolujecie itd.?
Macie jakiś worklog.md?
Co z gitem?

Przykład - jakiś miesiąc temu to był mój framework:
https://github.com/jarekratajski/plz/blob/main/ai/rules/general.md

Obecnie znacznie to uprościłem, ale nie mam przykładu w publicznym repo.
Na pewno za to są przykłady do użycia.

Moje do tej pory wnioski

  1. powyższy przykład jest mega przeinżynierowany :-( (powstał w czasach sonnet 4.5)
    obecnie tylko każe Klaudiuszowi prowadzić worklog.md i architecture.md -> żeby mieć aktualne stan prac
  2. Każe Klaudiuszowi samemu commitować do git - wygodniej niż wymyślać co wpisać w commity (pierwszy raz w moim życiu mam sensowne opisy commitów)
  3. Żadne reguły typu "remember to never use var" etc. nie działają w dłuższym czasie -> jak chcemy miec jakąś jakość kodu musi być twardy build i linter, który to sprawdza
SL
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 1104
3

Jak wrzucacie zadania?

Albo adres do JIRY/Githuba z taskiem albo piszę z palca. Generalnie jeszcze pół roku temu starałem się pisać bardzo dobrego prompta z wieloma iteracjami tj. tworzę nową konwersację z poprawionym promptem jak widzę, że claud odjeżdza. Teraz po prostu wrzucam co mi się nie podoba, bo model (najnowszy Opus) trochę lepiej ogarnia bloat w kontekscie

Jak kontrolujecie itd.?

git diff . Ja mam ten problem, że pracuję teraz w projekcie, którego za bardzo nie da się testować (integracja z zewnętrznymi programami sterowanymi w czasie rzeczywistym), ale generalnie gdy się da to lubię najpierw skupić się na testach a potem niech kladiusz się poci

Macie jakiś worklog.md?

Mam swojego CLAUDE.md wygenerowanego przez clauda z niewielkimi modyfikacjami . Jak dojdę to momentu gdy dużo wiedzy na temat tego jak coś ma być zrobione zostaje w kontekscie to piszę prompta, żeby zachować tą wiedzę w formie dokumentacji dla przyszłych pokoleń

Co z gitem?

Używam po staremu tj. daję konkretne instrukcje co ma się wydarzyć tj. zrób commit, zrebasuj, zrób unstasha i napraw konflikty .

Każe Klaudiuszowi samemu commitować do git - wygodniej niż wymyślać co wpisać w commity (pierwszy raz w moim życiu mam sensowne opisy commitów)

Lubię używać wygenerowane commit message jako punkt startowy, ale Claud jak i wszystkie AI nie potrafią generować komentatrzy. Jest dużo niepotrzebnych ogólników a mało konkretnego mięska, który wzbogaca kod

Żadne reguły typu "remember to never use var" etc. nie działają w dłuższym czasie -> jak chcemy miec jakąś jakość kodu musi być twardy build i linter, który to sprawdza

Tak, dobre testy i dużo lintowania to konieczność. Ostatecznie trzeba założyć, że instrukcje i dokumentacja nie będą przeczytane

Co do twojego projektu: ja bym bardziej szedł z kierunku pisania linterów przy pomocy AI (lub niech szuka czegoś w internecie) zamiast opasłej dokumentacji

bagietMajster
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 455
3

Testowałem bardzo dużo różnych sposobów, metod, planów, wielo/jedno plikowych, MCP/bez MCP, modyfikowałem zadania, zostawiałem tak jak było, pozwalałem na dostęp do bazy/api, zabraniałem dostępów. Wyniki moich testów jest następujący: nie ma to znaczenia dla klaudiusza, i tak zrobi co chce, i tak pominie co chce a jak go manualnie nie przypilnujesz to zrobione nie będzie. Uważam że less is more w przypadku MD, ważne żeby sobie dodawać rzeczy które są ważne/które nas denerwują do Claude.MD żeby tego nie powtarzać ciągle.

Pyxis
  • Rejestracja: dni
  • Ostatnio: dni
2

Testowałem najświeższe GPT-5.x Codex-y na bardziej złożonych zadaniach, tak by przygotował produkt od A do Z. W zasadzie przekazałem mu w SKILLS-ach czego oczekuję, w czym piszemy, jakie ma dodatkowe biblioteki do dyspozycji, jakie frameworki i moduły dociągnąć, gdy będzie taka potrzeba. Zaznaczyłem również, żeby implementował tylko to, co niezbędne i rozbijał taska na mniejsze punkty (taki planner), który pozwalał mi je przeanalizować i sprawdzić, czy w ogóle to ma sens. Jeśli akceptuję, to przechodzi do implementacji.

Następnie z okienka z czatem z poziomu IDE ładowałem mu SKILLS.md i dawałem zadanie w stylu korpo-jiry taska: Przygotuj serwis, który poprzez API robi to i tamto. Kilka punktów, bardzo generyczny opis z ogólnymi wymaganiami. Do tego miałem jakieś proste testy, które pozwoliły stwierdzić, że aplikacja w ogóle działa. Dostawałem zwykle sensowny plan rozbity na parę punktów. Prosiłem o implementację, więc wyglądało to tak, że agent najpierw wykonywał pewne polecenia w oknie czatu. Zawsze prosił o potwierdzenie, czy wykonać tymczasowe zadanie, choć mogłem dać zielone światło na wszystkie komendy. Oczywiście nie dałem.

Takich iteracji było wiele, co pozwalało mu eksplorować środowisko, np. czy może się połączyć z bazą, czy mam zainstalowaną daną paczkę itd. Jak punkt z planu był pokryty kodem, to czekał na jego akceptację i szedł dalej. Gdy wykonał wszystkie punkty, a ja zaakceptowałem wykonywanie finalnej aplikacji, to na końcu wykonywał testy. Często musiał wtedy się poprawiać, ale generalnie było to autonomiczne, ja tylko akceptowałem wykonywanie kodu z jego modyfikacjami.

Wnioski: pomimo, że prosiłem o minimalny kod, to był on dla mnie dziwny, na zasadzie łapiemy generyczny Exception. Chyba lepiej, by w ogóle tego nie dodawał. Ogólnie kod był dla mnie niezrozumiały, umieszczał pomocnicze funkcje w celach debuggingu. Potem musiałem się upominać o refaktoryzację, by je usunął. Dodatkowo dodawał bardzo sprecyzowane wyjątki, czyli jak gdzieś w flow zrozumiał, że wysłanie wartości 10 powoduje błąd, to hardkodował tę wartość w if-e. Ja to odbieram tak, że jego celem było dostarczenie produktu, więc każde potknięcie po drodze to był hotfix, byleby działało. Natomiast LLM działa całkiem dobrze, jak mamy pogadać o koncepcji, czy nawet poprosić o napisanie jednej funkcji z dobrze zdefiniowanymi warunkami brzegowymi. Tylko że realnie takie coś nie przyspiesza pracy. Taki kod trzeba przemyśleć dokładnie w ten sam sposób, jak trzeba by go wymyślić od zera. W złożonych systemach, czy legacy, LLM raczej się pogubi.

Podkreślę, że to były testy na green field, by wyrobić sobie opinię i sprawdzić, czy rzeczywiście zawód programisty jest zagrożony. Nie podpisałbym się pod takim kodem na produkcji. W moim odczuciu dowiezienie produktu nie może być jednym kryterium i wiem, że biznes myśli inaczej, ale to nic. Dług technologiczny prędzej czy później się zemści i wtedy biznes zapłaci podwójnie, choć niewykluczone, że jakiś % firm wyrobi znaczne zyski i zwinie się, gdy narracja o AI się zmieni.

CZ
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 2657
0

W moim odczuciu dowiezienie produktu nie może być jednym kryterium i wiem, że biznes myśli inaczej, ale to nic. Dług technologiczny prędzej czy później się zemści i wtedy biznes zapłaci podwójnie, choć niewykluczone, że jakiś % firm wyrobi znaczne zyski i zwinie się, gdy narracja o AI się zmieni.

Tylko zapomniałeś o jednej ważnej rzeczy. Kod z AI stał się o wiele tańszy. W związku z tym być może zamiast utrzymywać jakiś produkt będzie się go pisać od nowa co iterację. Nie będziemy musieli pisać kodu który ma być „maintainable” i „scalable”. Jedynie nasz metajęzyk do komunikacji z AI taki będzie musiał być.

Pyxis
  • Rejestracja: dni
  • Ostatnio: dni
0
Czitels napisał(a):

Tylko zapomniałeś o jednej ważnej rzeczy. Kod z AI stał się o wiele tańszy. W związku z tym być może zamiast utrzymywać jakiś produkt będzie się go pisać od nowa co iterację.

Z takim podejście nie ma szans na innowacje, bo każda kolejna iteracja to sklejanie czegoś na bazie ograniczonego fundamentu. W końcu AI zacznie się uczyć na słabym kodzie, który wygenerowało i umyka jej już uniwersalność. Bo o ile generalizacja to taki trzon sieci neuronowych, o tyle generalizowanie na kodzie, który nie jest uniwersalny, a bardzo ograniczony do konkretnych danych, prowadzi donikąd.

CZ
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 2657
0
Pyxis napisał(a):

bo każda kolejna iteracja to sklejanie czegoś na bazie ograniczonego fundamentu.

Mi chodziło o generowanie kodu w całości od nowa tylko z zmienionymi wymaganiami. Jakiekolwiek bazowanie na poprzednim kodzie nie ma sensu, bo wtedy wchodzimy w pisanie w znany nam już sposób.

YA
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 2395
0

Póki co jestem na etapie zabawy i uczenia się jak korzystać efektywnie. Idę w kierunku stworzenia workflow, w którym będzie dużo lokalnych narzędzi, ale mocno wyspecjalizowanych, zaś agent będzie odpowiedzialny za orkiestrację.

Problemy, które zaobserwowałem:

  • dopóki okno kontekstu nie jest w pełni wykorzystane jest ok, później agent doświadcza wybiórczej amnezji
  • zmiany w kodzie często kończą się niepowodzeniem (patch nie wszedl/nie kompiluje się -> "o przpepraszam, zła tabulacja/ sygnatura/wygląda że jest jeszcze kilka miejsc do poprawy/...")
  • utrzymanie skupienia (tak jak w wikipedii zaczynamy coś czytać o fizyce kwantowej i parę kliknięc później jestem już w temacie Bitwy pod Salaminą)
  • utrzymanie dyscypliny jakościowej/bezpieczeństwa/wersjonowania (tu nie widzę innej możliwości jak wymuszanie checków, np. archunitem, czy innymi guardami)
  • utrzymywanie jednego BACKLOG.md / TASKS.md wraz z upływem czasu i rozrostem plików źle wpływa na agenta

Na start wymyśliłem sobie zestaw narzędziowy, który będzie rozwijany jako osobny byt i w jakiś sposób będzie w stanie redukować problemy / usprawniać zarządzanie nimi.
Obecnie narzędzia w pewnym sensie są self-hosted, tzn. rozwijane z wykorzystaniem tego toolkitu. Kolejnym krokiem będzie sprawdzenie na ile będą użyteczne do poprawienia istniejącego kodu.

Główne założenia:

  • agent robi discovery dostępnych narzędzi, zgłasza zapotrzebowania na narzędzia, tworzy je

  • kod źródłowy reprezentowany jest jako baza faktów:

    • pliki -> projekcja faktów
    • zmiany -> aktualizacja bazy faktów
    • analiza wpływu zmian -> odpytywanie bazy
    • ocena kodu -> przepuszczenie przez zestaw reguł
  • agent planuje, rozpisuje taski, zależności i je utrzymuje

  • ma być możliwość ustawiania aktywnego kontekstu / tasku / ... (czyli jak wpadnie na pomysł, że można w dalszej kolejności zrobić A/B/C, to po mojej ocenie, np. B jest od czapy, A warto dodać jako osobnego rozpisanego taska na przyszłość, zaś w najbliższym czasie zająć się C).

Miks angielskiego i polskiego to moja wina, agent się dostosował dość mocno :-) Wynika to z faktu, że czasm sesje robię po polsku, czasem po angielsku.

Przykład AGENTS.md dla ATOOLS (robocza nazwa narzędzia):

Kopiuj
# AGENTS.md

## Rola repo

To repozytorium przechowuje wspolny zestaw narzedzi dla agentow kodujacych. Narzedzia sa rozwijane iteracyjnie, wersjonowane w `git` i udostepniane innym projektom przez `git submodule`.

## Zasady pracy

- Zanim dodasz nowe narzedzie, dopisz je do `toolkit.yaml`.
- Kazde narzedzie musi miec wlasny katalog pod `tools/<nazwa>/`.
- Kazde narzedzie powinno zawierac:
  - `README.md`
  - `tool.yaml`
  - opcjonalny katalog `prompts/`, `scripts/` lub `templates/`
- Jezeli narzedzie wymaga infrastruktury, najpierw dopisz lub zaktualizuj odpowiednie uslugi w `docker/compose.yaml`.
- Zmiany utrzymuj w `git` w malych, czytelnych commitach.
- Nie zakladaj, ze projekt-klient zna wewnetrzna strukture repo. Publiczny punkt wejscia to `scripts/toolkit.sh` i pliki `README`.
- Przy discovery narzedzi zaczynaj od `scripts/toolkit.sh catalog`, a potem `scripts/toolkit.sh describe <tool-id>`.
- Status narzedzia musi byc jawny w `tool.yaml`: `proposed`, `in-development` albo `ready`.
- Runtime narzedzia musi byc jawny w `tool.yaml`; shell nie jest wymagany, a Python jest pelnoprawnym runtime dla narzedzi.
- Nowe narzedzie dodawaj preferencyjnie przez `scripts/toolkit.sh create-tool <tool-id> <category> <status> <runtime>`, a potem uzupelnij wygenerowane pliki.
- Przy dodawaniu nowego narzedzia stosuj workflow z `NEW_TOOL_KICKSTART.md`.
- Przed `discovery sync` zawsze uruchom `scripts/toolkit.sh discovery validate`.

## Standard dodawania nowego narzedzia

1. Dodaj wpis do `toolkit.yaml`.
2. Dodaj katalog `tools/<nazwa>/`.
3. Jezeli trzeba, dopisz serwisy do `docker/compose.yaml`.
4. Udokumentuj zaleznosci, profile Compose i sposob uzycia.
5. Upewnij sie, ze narzedzie da sie wykryc z poziomu `scripts/toolkit.sh list`.

Przykład drzewa zależności:

Kopiuj
...
TASK-0047 [done] Enable end-to-end complex project delivery with ATOOLS
  TASK-0046 [done] Implement operator dashboard shell
  TASK-0048 [done] Implement documentation workbench
  TASK-0049 [done] Strengthen end-to-end evidence and traceability linking
  TASK-0050 [done] Expand project-file-editor and change-plan execution
  TASK-0051 [done] Extend project-bootstrap for complex project seeds
  TASK-0052 [done] Grow dashboard into default project operations read surface
  TASK-0053 [done] Re-evaluate need for dedicated execution runner
  TASK-0054 [done] Re-evaluate need for dedicated delivery evidence log
  TASK-0055 [done] Re-evaluate need for architecture scaffold tool
  TASK-0056 [done] Re-evaluate need for dependency intelligence workspace
  TASK-0057 [done] Re-evaluate need for delegated dashboard write actions
  TASK-0058 [done] Modernize toolkit CLI ergonomics
    TASK-0059 [done] Design modular toolkit.py command model
    TASK-0060 [done] Implement modular toolkit.py entrypoint
    TASK-0061 [done] Add shell completion and rich terminal rendering
    TASK-0062 [done] Re-evaluate need for interactive toolkit TUI
...

Przykład planowanego zadania do session handover.

Kopiuj
codex@box:~/ATOOLS$ ./scripts/toolkit.sh tasks list | grep -i hand
TASK-0090 [planned] parent=TASK-0075 depends_on=TASK-0080 components=toolkit-adoption, toolkit-docs tags=handoff, workflow, reporting description=Design delivery handoff and session summary workflow
codex@box:~/ATOOLS$ ./scripts/toolkit.sh tasks list^C
codex@box:~/ATOOLS$ ./scripts/toolkit.sh tasks show TASK-0090
id: TASK-0090
status: planned
description: Design delivery handoff and session summary workflow
parent_id: TASK-0075
depends_on: TASK-0080
pending_dependencies: -
components: toolkit-adoption, toolkit-docs
tags: handoff, workflow, reporting
created_at: 2026-03-18T15:36:00+00:00
updated_at: 2026-03-18T15:36:00+00:00
implementation_plan: ## Goal
Przyspieszyc przekazywanie pracy miedzy agentami i czlowiekiem przez repo-first summary sesji i delivery handoff.

## Scope
- zdefiniowac minimalny model summary: taski, wykonane kroki, odpalone walidacje, evidence, otwarte ryzyka, recommended next step
- zdecydowac, czy to ma byc generowany raport, zapis do documentation-workbench, czy nowy artefakt w istniejacym workspace
- powiazac summary z `change-plan`, `task-backlog`, `verification-profiles` i dashboardem
- uniknac duplikacji calego work-logu

## Validation
- po sesji agent moze wygenerowac zrozumialy handoff bez recznego skladania calego statusu
- kolejna sesja ma nizszy koszt wejscia w stan pracy

Przykład dla agentów korzystających:

Kopiuj
# AGENTS_ATOOLS.md

Ten plik jest dla agenta pracujacego w projekcie-kliencie, do ktorego dodano ATOOLS jako submodule.

Nie opisuje rozwoju samego repo ATOOLS. Opisuje, jak uzywac ATOOLS do realnej pracy nad projektem.

## Po co sa ATOOLS

ATOOLS maja zmniejszyc koszt pracy "z pamieci". Zamiast trzymac plan i stan zmiany tylko w rozmowie albo w glowie agenta, zapisuj je repo-first w `.toolkit/`.

Najwazniejsze zasady:

- publiczny entrypoint to `./scripts/toolkit.sh` z submodule ATOOLS
- najpierw czytaj kontrakty tooli przez `catalog` i `describe`
- planuj zmiany w store ATOOLS, nie tylko w odpowiedzi tekstowej
- wykonanie zmian oddzielaj od authoringu planu
- evidence i wyniki walidacji zapisuj z powrotem do store
- dashboard jest read-only; zapisy rob przez jawne komendy CLI

## Jak zaczynac prace

Jesli w projekcie jest ATOOLS, zacznij od:


./scripts/toolkit.sh catalog
./scripts/toolkit.sh describe project-bootstrap
./scripts/toolkit.sh describe change-plan
./scripts/toolkit.sh describe project-file-editor
./scripts/toolkit.sh describe verification-profiles
./scripts/toolkit.sh describe operator-dashboard


Jesli projekt nie ma jeszcze lokalnych store `.toolkit/*`, zainicjalizuj je przez bootstrap:


./scripts/toolkit.sh bootstrap init --profile complex --project-id my-project --display-name "My Project"


Jesli store juz istnieja, nie bootstrapuj ponownie bez powodu. Najpierw obejrzyj stan:


./scripts/toolkit.sh context focus show
./scripts/toolkit.sh tasks ready
./scripts/toolkit.sh dashboard snapshot


## Jak wznowic poprzednia sesje

ATOOLS nie maja jeszcze pelnego, dedykowanego workflow `handoff`, ale juz teraz da sie sensownie odzyskac stan pracy po poprzedniej sesji.

Minimalny zestaw:


./scripts/toolkit.sh context focus show
./scripts/toolkit.sh tasks ready
./scripts/toolkit.sh dashboard snapshot


Jak to czytac:

- `context focus show` daje glowny rekord pracy, objective i zrodla postepu
- `tasks ready` pokazuje, co jest gotowe do kontynuacji bez dalszych zaleznosci
- `dashboard snapshot` daje szerszy obraz gapow, traceability i governance attention

Jesli chcesz wejsc glebiej, zwykle warto od razu sprawdzic:


./scripts/toolkit.sh tasks tree
./scripts/toolkit.sh requirements coverage REQ-0001
./scripts/toolkit.sh change-plan show CP-0001


Zasada praktyczna:

- jesli poprzednia sesja ustawila poprawnie `focus`, to od niego zaczynaj

...

Zarejestruj się i dołącz do największej społeczności programistów w Polsce.

Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.