Jak poprawić developer experience, gdy budujesz sam
Summary
Poprawa developer experience przy pracy solo sprowadza się do skrócenia pętli między zmianą a wynikiem oraz ochrony czasu na skupienie. Zacznij od pomiaru czterech liczb: edycji, testów, builda i deployu. Potem usuń najtańsze tarcia, czyli setup jednym poleceniem, uruchamianie tylko zmienionych testów, cache i formatowanie przy zapisie. Narzędzia AI stosuj tam, gdzie realnie skracają czekanie, a nie tam, gdzie przerzucają pracę na review i zabierają uwagę.
Jak poprawić developer experience? Sprowadza się to do jednego ruchu: skróć czas między „zmieniłem linijkę” a „wiem, czy to zadziałało”, a potem chroń godziny, w których naprawdę da się myśleć. Reszta jest drugorzędna. Najpierw napraw wolne buildy, niestabilne testy, bolesny setup i hałaśliwe przerwania, w tej kolejności. Narzędzi AI używaj tam, gdzie usuwają czekanie, a nie tam, gdzie dokładają pracy przy review.
Jest w tym jedna rzecz, o której rzadko się mówi. Kiedy budujesz sam, jesteś jednocześnie zespołem platformy, klientem i osobą, do której przychodzą alerty. To przewaga. Możesz naprawić to, co irytuje cię w tym tygodniu, a nie w przyszłym kwartale.
Co tak naprawdę oznacza developer experience, gdy budujesz sam?
Większość poradników o DX pisano dla firm z zespołem platformy i budżetem na ankiety. Pomysły i tak się przenoszą, bo badania za nimi stoją na prostej logice. Głośny artykuł w ACM Queue dzieli DevEx na trzy wymiary: pętle sprzężenia zwrotnego, obciążenie poznawcze i stan skupienia.
Pętle sprzężenia zwrotnego to czas, jaki czekasz na odpowiedź narzędzi albo ludzi. Obciążenie poznawcze to liczba rzeczy, które musisz trzymać w głowie, żeby zrobić zmianę. Stan skupienia to to, czy masz dość długie okna bez przerw, żeby zrobić trudne rzeczy.
Nikt nie czuje tych trzech elementów jako abstrakcji. Czujesz je jako test, którego unikasz, repozytorium, którego boisz się dotknąć po dwóch tygodniach przerwy, i laptop, który pika co cztery minuty.
Microsoft w omówieniu tych badań na blogu Azure podaje liczby, które warto zapamiętać. Deweloperzy, którzy mieli w tygodniu wyraźnie wydzielony czas na głęboką pracę, czuli się o 50% bardziej produktywni niż ci bez takiego czasu. Zespoły, które szybko odpowiadały na pytania, raportowały o 50% mniej długu technicznego. To wyniki oparte na ankietach odczuć, a nie na kontrolowanym eksperymencie, więc traktuj je jako kierunek, a nie obietnicę.
W projekcie pobocznym przełożenie jest proste. Twoje DX to suma drobnych tarć między tobą a działającą funkcją we wtorek o 22:00.
Od czego zacząć: zmierz pętlę, zanim ją naprawisz
Wybierz pętlę, którą powtarzasz najczęściej. U większości osób to: edycja, zapis, zobaczenie wyniku. Mierz ją stoperem, a nie wrażeniem.
Orientacyjna skala, która sprawdza się w praktyce:
Poniżej 1 sekundy: hot reload albo tryb watch działa natychmiast, zostajesz w problemie.
Od 1 do 10 sekund: w porządku, zerkniesz w inne okno, ale nie zgubisz wątku.
Od 10 do 60 sekund: sięgniesz po telefon. Tu zaczyna uciekać skupienie.
Ponad minutę: zaczniesz grupować zmiany, a to oznacza większe błędy i trudniejsze debugowanie.
Zrób to samo dla uruchomienia testów, pełnego builda i deployu. Zapisz te cztery liczby w notatce na początku repozytorium. To twoja baza wyjściowa i dzięki niej kolejna poprawka ma konkretny cel.

Podobne rady padają w większych zespołach. Przewodnik Swarmii sugeruje, by problemy z czasem oczekiwania rozwiązywać jeden po drugim, zaczynając od tych prostych. To wymusza priorytety i sprawia, że efekt jest łatwo widoczny. Dla jednej osoby logika jest taka sama jak dla pięćdziesięciu.
Ufaj stoperowi, a nie intuicji. Pętla, która wydaje się najwolniejsza, często nie jest tą, która marnuje najwięcej czasu. Sprawdzanie typów trwające 12 sekund, odpalane 300 razy dziennie, kosztuje więcej niż czterominutowy deploy uruchamiany dwa razy.
Które tarcie usunąć najpierw, bo kosztuje najmniej?
Niektóre poprawki zajmują popołudnie, a zwracają się przez miesiące. Zrób je przed czymkolwiek efektownym.
Setup w jednym poleceniu. Jeśli świeży klon nie działa po jednym make dev albo npm run dev, dopłacasz do każdego przełączenia kontekstu, także tego po miesiącu przerwy. Kroki wrzuć do skryptu, a nie do akapitu w README.
# bootstrap.sh: jedyny krok konfiguracji, jakiego projekt powinien wymagać
set -euo pipefail
cp -n .env.example .env
npm ci
npm run db:migrate
echo "gotowe: uruchom npm run dev"Uruchamiaj tylko to, co się zmieniło. Włącz tryb watch albo tryb powiązanych plików w swoim runnerze testów, żeby zapis uruchamiał trzy dotknięte testy, a nie wszystkie 900. Większość nowoczesnych runnerów obsługuje to od ręki.
Cache'uj to, co wolne. Instalacje zależności, warstwy Dockera i wyniki buildów to typowi winowajcy. Jeśli CI trwa 8 minut, bo wszystko instaluje od nowa, klucz cache oparty na pliku lockfile często skraca to do poniżej 3 minut.
Usuń niestabilne testy albo napraw je dziś. Test, który raz przechodzi, a raz nie, uczy cię ignorować czerwony kolor. Dobrym tymczasowym rozwiązaniem jest przeniesienie go do osobnego joba zamiast zostawiania w głównym przebiegu, pod warunkiem że ustawisz termin naprawy.
Formatuj i lintuj przy zapisie. Dyskusje o stylu kosztują uwagę. Niech narzędzie je rozstrzygnie i idź dalej.
Nic z tego nie jest ekscytujące. O to chodzi. Każda z tych rzeczy usuwa decyzję, którą podejmujesz kilkadziesiąt razy w tygodniu.
Ile obciążenia poznawczego dokłada twój kod?
Projekt poboczny starzeje się w jeden konkretny sposób: zapominasz, dlaczego rzeczy są takie, a nie inne. Po trzech miesiącach kod wygląda jak zagadka napisana przez obcego, który przypadkiem pisze w twoim stylu.
Najtańsza obrona to spisywanie decyzji, a nie dopracowywanie dokumentacji. Plik DECISIONS.md z jednym akapitem na wybór („użyłem SQLite, bo cały zbiór mieści się w pamięci, wrócić do tematu powyżej 50 tys. wierszy”) oszczędza więcej czasu niż ładne README. Thoughtworks wymienia dokumentację, w tym rekordy decyzji architektonicznych, wśród czterech podstaw DX. Wersja dla jednej osoby to ta sama idea, tylko w jednej dziesiątej wagi.

Trzy nawyki, które obniżają obciążenie bez ceremonii:
Nazywaj rzeczy tak, jak robią, i zmieniaj nazwę szybko, gdy przestaje być prawdziwa.
Miej jeden oczywisty sposób na każde częste zadanie: jeden sposób pobierania danych, jeden sposób obsługi błędów, jedno miejsce na konfigurację.
Na koniec sesji zostaw failing test albo komentarz
TODO(next), żeby jutro zaczynać od kroku, a nie od pustej kartki.
Architekturę w tym miejscu odpuść. Dziesięciowarstwowa struktura folderów dla aplikacji na 2000 linii dokłada obciążenia, zamiast je zdejmować. Dodawaj strukturę wtedy, gdy coś zaczyna boleć, a nie z góry.
Czy AI poprawia developer experience, czy tylko przenosi ból?
Jedno i drugie, zależnie od tego, gdzie je skierujesz. Po miesiącach codziennego używania uczciwa odpowiedź brzmi tak: narzędzia AI błyszczą w powtarzalnej części pracy, przy wyszukiwaniu i pierwszych szkicach. Kosztują cię wtedy, gdy akceptujesz kod, którego nie rozumiesz.
Dobre zastosowania, w kolejności, w jakiej sam bym je wdrażał:
Uzupełnianie w edytorze przy powtarzalnym kodzie. Niskie ryzyko, natychmiastowa informacja zwrotna, a i tak czytasz każdą linijkę.
Wyjaśnianie obcego kodu albo stack trace'a. To bezpośrednio zmniejsza obciążenie poznawcze i czas szukania.
Pisanie testów do kodu, który już napisałeś. Oceniaj je ostro, ale pierwszy szkic realnie oszczędza czas.
Edycje agentowe w wielu plikach przy mechanicznych refaktorach, z czystym stanem gita, żeby wynik dało się odrzucić.
Narzędzia różnią się tym, gdzie żyją. Jedne siedzą w edytorze, inne w terminalu, jeszcze inne w przepływie pull requestów:
Przy pracy w terminalu agent, który czyta repozytorium i uruchamia polecenia, pasuje do innego nawyku niż wtyczka do edytora:
Jedno ostrzeżenie, które perspektywa DX czyni oczywistym. Jeśli narzędzie przyspiesza pisanie kodu, a spowalnia jego review, przeniosłeś czekanie z jednej pętli do drugiej. Pilnuj, ile minut zjada czytanie wygenerowanych diffów. Jeśli więcej czasu zabiera czytanie, niż oszczędza pisanie, zawęź zakres tego, o co prosisz.
Druga pułapka: nie dawaj agentowi mglistego celu i nie odchodź od komputera. Daj mu jedno małe zadanie z testem, który sam może uruchomić, na przykład failing test, i oceniaj go po tym, czy ten test przechodzi.
Jak chronić czas skupienia, na którym opiera się wszystko inne?
Liczba z badania Microsoftu o głębokiej pracy to ta, od której zacząłbym, nawet z jej ograniczeniami. Skupienie mnoży efekt każdej innej poprawki z tego tekstu.
Solo buildera najczęściej rozprasza on sam: powiadomienia, zakładki, nowe wydanie frameworka, poczucie, że trzeba sprawdzić analitykę. Poprawki są nudne, ale działają:
Zablokuj dwie sesje w tygodniu, każda co najmniej po 90 minut, z wyłączonymi powiadomieniami i zamkniętym czatem.
Zdecyduj, co budujesz, zanim usiądziesz. Otwarcie edytora, żeby „zobaczyć, co wyjdzie”, to najprostszy sposób, w jaki znika godzina.
Prowadź plik parkingowy. Gdy przyjdzie boczna myśl, zapisz jedną linijkę i wróć do pracy.
Kończ sesję w czystym miejscu, a nie w połowie myśli, chyba że zostawisz notatkę.

Jeśli pracujesz dla klientów w różnych strefach czasowych, jak wielu builderów w Tajpej, Bangkoku czy Manili, pilnuj wspólnych godzin inaczej. Umieść spotkania z klientami w jednym zwartym bloku, a resztę dnia zostaw na budowanie. Jedna 20-minutowa przerwa potrafi kosztować znacznie więcej niż 20 minut skupienia.
Co mierzyć, żeby wiedzieć, że to działa?
Nie buduj dashboardu. Co miesiąc powtórz te same cztery pomiary: edycja i wynik, testy, pełny build, deploy. Dodaj jeszcze jedną ocenę od 1 do 5: jak irytujący był ten tydzień do budowania?
Miara odczuć ma znaczenie. Microsoft w swoim badaniu zestawia to, co czują deweloperzy, z danymi o przepływie pracy, bo jedno potrafi się rozjechać z drugim. Proces review może wyglądać szybko na wykresie i mimo to męczyć. Dla jednej osoby logika jest ta sama. Jeśli liczby się poprawiają, a ocena nie, coś innego jest nie tak, zwykle skupienie albo zakres.
Warto też nazwać kompromisy. Każda poprawka ma koszt utrzymania. Własny skrypt to kolejna rzecz do zepsucia. Rozbudowany monorepo może kosztować więcej, niż oszczędza, gdy projekt ma jednego współtwórcę. Wybieraj zwykłe, sprawdzone domyślne ustawienia i napraw coś dopiero wtedy, gdy ugryzie cię dwa razy.
Która poprawka DX pasuje do projektu, który dopiero zaczynasz?
Jeśli dopiero wybierasz, co zbudować, potraktuj DX jako kryterium wyboru. Projekt z szybką pętlą, małym stackiem i jasnym zakresem przetrwa trzeci tydzień, czyli moment, w którym ginie większość weekendowych projektów. Projekt, który wymaga pięciu usług uruchomionych lokalnie, zanim zobaczysz choćby jeden piksel, często nie przetrwa.
Zanim zaczniesz, zadaj sobie trzy pytania. Czy zobaczę wynik w mniej niż 10 sekund? Czy świeży klon uruchomię jedną komendą? Czy pierwszą wersję opiszę w dwóch zdaniach? Trzy odpowiedzi „tak” to dobry znak. Dwa „nie” oznaczają, że zmniejszasz pomysł, a nie standardy.
To nie jest idealny pomysł. To jest wykonalny pomysł. A wykonalny pomysł z szybką pętlą wygrywa z ambitnym, do którego przestajesz wracać.
Którą pętlę zmierzysz jako pierwszą: zapis, uruchomienie testów czy deploy?