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ę.

Biurko dewelopera nocą z ultraszerokim monitorem pokazującym kod i ciepłą lampą

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:

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.

Terminal na laptopie z prawie gotowym buildem obok stopera

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.

Widok z góry na biurko dewelopera z odręczną listą kontrolną i karteczkami

Trzy nawyki, które obniżają obciążenie bez ceremonii:

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ł:

  1. Uzupełnianie w edytorze przy powtarzalnym kodzie. Niskie ryzyko, natychmiastowa informacja zwrotna, a i tak czytasz każdą linijkę.

  2. Wyjaśnianie obcego kodu albo stack trace'a. To bezpośrednio zmniejsza obciążenie poznawcze i czas szukania.

  3. Pisanie testów do kodu, który już napisałeś. Oceniaj je ostro, ale pierwszy szkic realnie oszczędza czas.

  4. 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ą:

Dwa monitory: uporządkowany edytor kodu i przegląd diffa

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?

Frequently asked questions

Czym jest developer experience przy pracy solo?
To suma drobnych tarć między tobą a działającą funkcją: czas czekania na build i testy, liczba rzeczy, które musisz pamiętać, i to, czy masz długie okna skupienia. Pracując solo, jesteś jednocześnie zespołem platformy i użytkownikiem swoich narzędzi.
Od czego zacząć poprawę DX?
Zmierz stoperem pętlę, którą powtarzasz najczęściej. Zapisz cztery liczby: edycja i wynik, testy, pełny build oraz deploy. Potem napraw najwolniejszą z prostych rzeczy, zaczynając od setupu w jednym poleceniu.
Jak szybko powinna działać pętla edycja i wynik?
Poniżej sekundy odczuwasz to jako natychmiastowe. Do 10 sekund jest w porządku. Powyżej 10 sekund zaczynasz sięgać po telefon, a powyżej minuty grupujesz zmiany, co zwiększa liczbę błędów.
Czy narzędzia AI poprawiają developer experience?
Tak, jeśli używasz ich do uzupełniania kodu, wyjaśniania obcego kodu i pierwszych szkiców testów. Jeśli przyspieszają pisanie, ale wydłużają review, przerzucasz czekanie z jednej pętli na drugą.
Ile czasu skupienia wystarczy?
W badaniu Microsoftu liczy się wyraźnie wydzielony czas na głęboką pracę. W praktyce wystarczą dwie sesje tygodniowo, każda co najmniej 90 minut, z wyłączonymi powiadomieniami.
Czy warto budować dashboard z metrykami DX?
Nie. Wystarczy raz w miesiącu powtórzyć te same cztery pomiary i dodać ocenę irytacji od 1 do 5. Dashboard to dodatkowy kod do utrzymania, a nic nie wnosi.
Kiedy dodać architekturę do projektu?
Wtedy, gdy coś zaczyna boleć, a nie z góry. Rozbudowana struktura warstw w małej aplikacji zwiększa obciążenie poznawcze zamiast je zmniejszać.