# eiac.dev — Everything Is A Code

> Pismo i katalog o zarządzaniu z kodu (everything-as-code): infrastruktura, aplikacje, design, SDLC i bezpieczeństwo. Teksty po polsku — pogłębione tezy z przykładami w kodzie i odnośnikami do oficjalnych źródeł. Treść przeznaczona także jako wsad merytoryczny dla agentów AI.

Pełna treść wszystkich artykułów w jednym pliku: https://eiac.dev/llms-full.txt
Surowy markdown pojedynczego artykułu: https://eiac.dev/blog/<slug>.md
Kanał RSS: https://eiac.dev/rss.xml

## Artykuły
- [Aplikacje z kodu: SST vs Encore](https://eiac.dev/blog/sst-vs-encore): Dwa podejścia do App-as-Code: elastyczny framework IaC (SST) kontra konwencja z infrastrukturą wywiedzioną z kodu (Encore). Model, przykłady, wady i zalety.
- [IaC w 2026 — przegląd pola](https://eiac.dev/blog/iac-2026-przeglad): Po trzęsieniu licencyjnym IaC rozszczepia się na trzech osiach: podejście, governance i autonomia. Cztery obozy narzędzi, warstwa typowanej konfiguracji, automatyzacja TACOS i wejście agentów.
- [Security Plane: sekrety, tożsamość i policy-as-code](https://eiac.dev/blog/security-plane-sekrety-tozsamosc-policy): Trzy filary Security Plane — tożsamość, sekrety i policy-as-code — działają razem, self-hostowane i opisane jako kod, spełniając jednocześnie wymóg suwerenności i audytowalnej autonomii.
- [Open source ≠ suwerenność: licencje i co-option chmury](https://eiac.dev/blog/open-source-a-suwerennosc): Otwarta licencja nie wystarcza do suwerenności. Open-core, zmiany licencji (BSL/SSPL), repackaging przez chmury i przejęcia — oraz test, który naprawdę definiuje sovereign-ready tooling.
- [Suwerenne AI w platformie: open-weight, lokalne GPU i ochrona IP](https://eiac.dev/blog/suwerenne-ai-open-weight): Bez modelu open-weight na własnej infrastrukturze data residency jest iluzją — najcenniejsze aktywa wyciekają przez asystenta. Suwerenne AI jako zarządzanie ryzykiem IP i ciągłości, z trzeźwym uznaniem kosztów.
- [AI Act a agentowy SDLC: regulacja kontra autonomia](https://eiac.dev/blog/ai-act-a-agentowy-sdlc): Wymogi AI Act — nadzór człowieka, ślad, transparentność, zarządzanie ryzykiem — mapują się niemal jeden do jednego na deterministyczny szkielet platformy agentowej. Regulacja jako specyfikacja, nie hamulec.
- [DORA w praktyce platformy: testowalne strategie wyjścia](https://eiac.dev/blog/dora-w-praktyce-platformy): DORA zamienia strategię wyjścia z dokumentu w udowadnialną zdolność operacyjną. Jak warstwy platformy — IaC, GitOps, policy-as-code — przekładają się wprost na zgodność.
- [Suwerenny IDP: exit-by-design jako architektura](https://eiac.dev/blog/suwerenny-idp-exit-by-design): Suwerenność to nie miejsce przechowywania danych, lecz przenośność workflowów. Jak everything-as-code i GitOps zamieniają strategię wyjścia z dokumentu w funkcję techniczną.
- [Deterministyczny szkielet platformy agentowej](https://eiac.dev/blog/deterministyczny-szkielet-adp): Nieprzewidywalną moc modeli zamienia w audytowalny wynik deterministyczny szkielet: walidacja-pętla, policy-as-code jako bramka, środowiska efemeryczne i tożsamość nie-ludzka.
- [Cztery poziomy agentowego wytwarzania oprogramowania](https://eiac.dev/blog/cztery-poziomy-agentowego-wytwarzania): Dojrzałość agentowa to nie ilość AI, lecz zmiana, kto inicjuje pracę. Poziomy 0–4, model paths-to-outcomes i to, jak walidacja zamienia się w pętlę.
- [Od IDP do ADP: platforma w erze agentów](https://eiac.dev/blog/od-idp-do-adp): Gdy część pracy w pętli przejmuje agent, platforma musi się zmienić — z IDP w ADP. Dlaczego przewaga nie leży w lepszym modelu, lecz w systemie produkcyjnym, który go ujarzmia.
- [Platform engineering: normalizacja pracy w organizacji](https://eiac.dev/blog/platform-engineering-normalizacja-pracy): Platform engineering to normalizacja pracy — kodowanie osądu raz i stosowanie go wszędzie. Wprowadzenie do serii: korzyści, koszty i moment, w którym platforma ma (lub nie ma) sensu.
- [Design-as-Code: tokeny jako standard UI w platformie agentowej](https://eiac.dev/blog/design-as-code-tokeny-od-zera): Tokeny zamieniają decyzje wizualne w jedno, audytowalne źródło prawdy. Dlaczego deterministyczną warstwę UI da się powierzyć agentowi, a UX zostaje przy człowieku w pętli.
- [Policy-as-Code dla zespołów: warstwa kontroli platformy](https://eiac.dev/blog/policy-as-code-dla-zespolow): Polityka, której nie da się uruchomić, to dokument. Jak zamienić bezpieczeństwo i zgodność w warstwową płaszczyznę kontroli — od PR po admission — egzekwowaną jako guardrail, nie bramkarza.
- [Wersjonowanie z automatu: SemVer i Conventional Commits](https://eiac.dev/blog/wersjonowanie-semver-conventional-commits): Wersja to interfejs komunikacyjny, nie kosmetyka. Jak SemVer i Conventional Commits zamieniają historię commitów w automatyczne, przewidywalne wydania — i gdzie kończy się sens automatu.

## Katalog narzędzi
- [age](https://eiac.dev/katalog/age): Proste, nowoczesne szyfrowanie plików z małymi kluczami. (Security-as-Code, BSD-3-Clause)
- [Ansible](https://eiac.dev/katalog/ansible): Bezagentowa automatyzacja konfiguracji i provisioningu (YAML). (Infrastructure-as-Code, GPL-3.0)
- [APM (Agent Package Manager)](https://eiac.dev/katalog/apm): Menedżer zależności dla agentów AI — skills, prompty, instrukcje, wtyczki i serwery MCP deklarowane w apm.yml. (SDLC / Policy-as-Code, MIT)
- [Argo CD](https://eiac.dev/katalog/argo-cd): GitOps dla Kubernetes — repo jako źródło prawdy o stanie klastra. (SDLC / Policy-as-Code, Apache-2.0)
- [Argo CD Vault Plugin](https://eiac.dev/katalog/argocd-vault-plugin): Wstrzykiwanie sekretów do manifestów Kubernetes w GitOps. (Security-as-Code, Apache-2.0)
- [Backstage](https://eiac.dev/katalog/backstage): Platforma developerskiego portalu (IDP) — katalog i szablony z kodu. (SDLC / Policy-as-Code, Apache-2.0)
- [Buildah](https://eiac.dev/katalog/buildah): Budowanie obrazów OCI bez demona — skryptowalne i daemonless. (App-as-Code, Apache-2.0)
- [Casbin](https://eiac.dev/katalog/casbin): Autoryzacja jako kod — RBAC/ABAC/ACL w wielu językach. (Security-as-Code, Apache-2.0)
- [cert-manager](https://eiac.dev/katalog/cert-manager): Automatyczne certyfikaty TLS w Kubernetes — deklaratywnie (CRD). (Security-as-Code, Apache-2.0)
- [Checkov](https://eiac.dev/katalog/checkov): Skan błędów konfiguracji w IaC i obrazach — policy-as-code w CI. (Security-as-Code, Apache-2.0)
- [ClusterFuzzLite](https://eiac.dev/katalog/clusterfuzzlite): Ciągły fuzzing uruchamiany w pipeline CI. (Security-as-Code, Apache-2.0)
- [Coder](https://eiac.dev/katalog/coder): Środowiska deweloperskie jako kod (CDE), provisionowane Terraformem. (App-as-Code, AGPL-3.0)
- [Conftest](https://eiac.dev/katalog/conftest): Testy konfiguracji (YAML/JSON/HCL) regułami Rego — policy-as-code w CI. (SDLC / Policy-as-Code, Apache-2.0)
- [Crossplane](https://eiac.dev/katalog/crossplane): Provisioning infrastruktury przez API Kubernetes (control plane). (Infrastructure-as-Code, Apache-2.0)
- [Dagger](https://eiac.dev/katalog/dagger): Pipeline'y CI/CD jako kod, uruchamiane w kontenerach, przenośne. (SDLC / Policy-as-Code, Apache-2.0)
- [Dex](https://eiac.dev/katalog/dex): Dostawca tożsamości OIDC z wtyczkami (federacja logowania). (Security-as-Code, Apache-2.0)
- [Encore](https://eiac.dev/katalog/encore): Backend-as-Code z własnym runtime i automatyczną infrastrukturą. (App-as-Code, MPL-2.0)
- [env0](https://eiac.dev/katalog/env0): Platforma TACOS z naciskiem na FinOps — wiele narzędzi IaC, RBAC, drift i samoobsługa. (Infrastructure-as-Code, Proprietary)
- [ExternalDNS](https://eiac.dev/katalog/external-dns): Rekordy DNS sterowane zasobami Kubernetes (DNS-as-code). (Infrastructure-as-Code, Apache-2.0)
- [Falco](https://eiac.dev/katalog/falco): Wykrywanie zagrożeń w runtime (Kubernetes/Linux) wg reguł. (Security-as-Code, Apache-2.0)
- [Flux](https://eiac.dev/katalog/flux): GitOps dla Kubernetes — Git jako źródło prawdy, ciągła synchronizacja. (SDLC / Policy-as-Code, Apache-2.0)
- [Gitea](https://eiac.dev/katalog/gitea): Self-hosted platforma Git: hosting, code review, rejestr i CI/CD. (SDLC / Policy-as-Code, MIT)
- [GitLab](https://eiac.dev/katalog/gitlab): Kompletna platforma DevOps: SCM, CI/CD, rejestr, security — self-hosted. (SDLC / Policy-as-Code, MIT)
- [Gitleaks](https://eiac.dev/katalog/gitleaks): Wykrywanie sekretów w repo i historii Git — w CI i pre-commit. (Security-as-Code, MIT)
- [gitsign](https://eiac.dev/katalog/gitsign): Bezkluczowe podpisywanie commitów Git przez Sigstore. (Security-as-Code, Apache-2.0)
- [Grype](https://eiac.dev/katalog/grype): Skaner podatności obrazów i systemów plików; parą z SBOM (Syft). (Security-as-Code, Apache-2.0)
- [Harbor](https://eiac.dev/katalog/harbor): Zaufany rejestr cloud-native — przechowuje, podpisuje i skanuje obrazy. (SDLC / Policy-as-Code, Apache-2.0)
- [Harness Open Source](https://eiac.dev/katalog/harness): Platforma developerska: SCM, CI/CD, środowiska i rejestry artefaktów. (SDLC / Policy-as-Code, Apache-2.0)
- [Helm](https://eiac.dev/katalog/helm): Menedżer pakietów dla Kubernetes — aplikacje jako wersjonowane charty. (App-as-Code, Apache-2.0)
- [Infisical](https://eiac.dev/katalog/infisical): Otwarta platforma do sekretów, certyfikatów i dostępu. (Security-as-Code, MIT)
- [Istio](https://eiac.dev/katalog/istio): Service mesh — ruch, bezpieczeństwo i obserwowalność deklaratywnie. (App-as-Code, Apache-2.0)
- [k3s](https://eiac.dev/katalog/k3s): Lekki, w pełni zgodny Kubernetes w jednym binarium. (App-as-Code, Apache-2.0)
- [kind](https://eiac.dev/katalog/kind): Kubernetes w Dockerze — lokalne, jednorazowe klastry do testów i CI. (App-as-Code, Apache-2.0)
- [Knative](https://eiac.dev/katalog/knative): Serverless na Kubernetes — skalowanie do zera, sterowane żądaniami. (App-as-Code, Apache-2.0)
- [kOps](https://eiac.dev/katalog/kops): Produkcyjny lifecycle klastrów Kubernetes z deklaratywnej specyfikacji. (Infrastructure-as-Code, Apache-2.0)
- [kube-bench](https://eiac.dev/katalog/kube-bench): Audyt klastra Kubernetes wg CIS Benchmark — compliance-as-code. (Security-as-Code, Apache-2.0)
- [Kubernetes](https://eiac.dev/katalog/kubernetes): Orkiestracja kontenerów — deklaratywny runtime dla aplikacji. (App-as-Code, Apache-2.0)
- [Kubescape](https://eiac.dev/katalog/kubescape): Platforma bezpieczeństwa Kubernetes — ryzyko, compliance, misconfig. (Security-as-Code, Apache-2.0)
- [Kubespray](https://eiac.dev/katalog/kubespray): Produkcyjny Kubernetes na dowolnych hostach przez Ansible. (Infrastructure-as-Code, Apache-2.0)
- [KubeVirt](https://eiac.dev/katalog/kubevirt): Maszyny wirtualne jako zasoby Kubernetes — VM-as-Code. (App-as-Code, Apache-2.0)
- [Kustomize](https://eiac.dev/katalog/kustomize): Bezszablonowe nakładki na manifesty Kubernetes (overlays). (App-as-Code, Apache-2.0)
- [Kyverno](https://eiac.dev/katalog/kyverno): Silnik polityk dla Kubernetes — polityki jako zasoby YAML (bez nowego języka). (Security-as-Code, Apache-2.0)
- [lego](https://eiac.dev/katalog/lego): Klient i biblioteka ACME (Let's Encrypt) — certyfikaty z kodu. (Security-as-Code, MIT)
- [Linkerd](https://eiac.dev/katalog/linkerd): Lekki, bezpieczny service mesh dla Kubernetes (mTLS z pudełka). (App-as-Code, Apache-2.0)
- [Longhorn](https://eiac.dev/katalog/longhorn): Rozproszony storage blokowy dla Kubernetes — deklaratywny i cloud-native. (App-as-Code, Apache-2.0)
- [MegaLinter](https://eiac.dev/katalog/megalinter): Wiele linterów i skanów (w tym security) w jednym kroku CI. (SDLC / Policy-as-Code, AGPL-3.0)
- [Nebula](https://eiac.dev/katalog/nebula): Skalowalna sieć overlay (mesh VPN) sterowana konfiguracją. (Security-as-Code, MIT)
- [Nitric](https://eiac.dev/katalog/nitric): Wielojęzyczny framework infrastructure-from-code — wymagania wywnioskowane z kodu, wdrożenie przez Terraform/Pulumi. (App-as-Code, Apache-2.0)
- [Nix](https://eiac.dev/katalog/nix): Powtarzalne buildy i środowiska z deklaratywnego, czystego opisu. (Infrastructure-as-Code, LGPL-2.1)
- [OPA Gatekeeper](https://eiac.dev/katalog/gatekeeper): Kontroler polityk dla Kubernetes — admission control na bazie OPA. (Security-as-Code, Apache-2.0)
- [Open Policy Agent](https://eiac.dev/katalog/open-policy-agent): Uniwersalny silnik polityk — zasady jako testowalny kod (Rego). (SDLC / Policy-as-Code, Apache-2.0)
- [OpenBao](https://eiac.dev/katalog/openbao): Otwarty fork Vault (MPL-2.0) do zarządzania sekretami. (Security-as-Code, MPL-2.0)
- [OpenTaco (Digger)](https://eiac.dev/katalog/digger): Open-source TACOS — orkiestracja IaC w Twoim CI, ze state management i RBAC; self-hostowalny. (Infrastructure-as-Code, Apache-2.0)
- [OpenTofu](https://eiac.dev/katalog/opentofu): Otwarty fork Terraform (MPL-2.0) zgodny z HCL i providerami. (Infrastructure-as-Code, MPL-2.0)
- [Ory Hydra](https://eiac.dev/katalog/ory-hydra): Certyfikowany serwer OAuth2/OIDC sterowany konfiguracją i API. (Security-as-Code, Apache-2.0)
- [Penpot](https://eiac.dev/katalog/penpot): Otwarte narzędzie do projektowania UI z design tokenami i eksportem. (Design-as-Code, MPL-2.0)
- [promptfoo](https://eiac.dev/katalog/promptfoo): Testy, ewaluacja i red-teaming LLM/agentów — deklaratywne configi. (Security-as-Code, MIT)
- [Pulumi](https://eiac.dev/katalog/pulumi): Infrastruktura jako kod w prawdziwych językach (TS, Python, Go). (Infrastructure-as-Code, Apache-2.0)
- [release-please](https://eiac.dev/katalog/release-please): Automatyczne wydania i changelog z Conventional Commits. (SDLC / Policy-as-Code, Apache-2.0)
- [Scalr](https://eiac.dev/katalog/scalr): TACOS jako drop-in zamiennik Terraform Cloud — ten sam model CLI/API/stanu, rozliczenie per run. (Infrastructure-as-Code, Proprietary)
- [semantic-release](https://eiac.dev/katalog/semantic-release): W pełni automatyczne wydania z Conventional Commits (publish-on-merge). (SDLC / Policy-as-Code, MIT)
- [Semaphore](https://eiac.dev/katalog/semaphore): UI i API dla Ansible, Terraform/OpenTofu/Terragrunt i innych narzędzi. (Infrastructure-as-Code, MIT)
- [SOPS](https://eiac.dev/katalog/sops): Szyfrowanie sekretów w plikach trzymanych w Git (GitOps-friendly). (Security-as-Code, MPL-2.0)
- [Spacelift](https://eiac.dev/katalog/spacelift): Platforma automatyzacji IaC (TACOS) — GitOps, drift detection i policy-as-code dla wielu narzędzi. (Infrastructure-as-Code, Proprietary)
- [SST](https://eiac.dev/katalog/sst): Pełne aplikacje na AWS definiowane w kodzie, ze świetnym DX. (App-as-Code, MIT)
- [Storybook](https://eiac.dev/katalog/storybook): Warsztat komponentów UI — dokumentacja i testy w izolacji. (Design-as-Code, MIT)
- [Style Dictionary](https://eiac.dev/katalog/style-dictionary): Generuje design tokeny do dowolnej platformy z jednego źródła. (Design-as-Code, Apache-2.0)
- [Task](https://eiac.dev/katalog/task): Nowoczesny task runner — automatyzacja w czytelnym pliku YAML. (SDLC / Policy-as-Code, MIT)
- [Teller](https://eiac.dev/katalog/teller): Cloud-native sekrety w terminalu — z wielu providerów naraz. (Security-as-Code, Apache-2.0)
- [Terraform](https://eiac.dev/katalog/terraform): Deklaratywne provisioning infrastruktury w HCL, multi-cloud. (Infrastructure-as-Code, BUSL-1.1)
- [Terragrunt](https://eiac.dev/katalog/terragrunt): Nakładka na Terraform/OpenTofu — DRY, środowiska i zależności. (Infrastructure-as-Code, MIT)
- [Terramate](https://eiac.dev/katalog/terramate): Open-source orkiestrator i generator kodu dla Terraform/OpenTofu — stacki, change detection, GitOps. (Infrastructure-as-Code, MPL-2.0)
- [Terrascan](https://eiac.dev/katalog/terrascan): Skan zgodności i bezpieczeństwa IaC przed provisioningiem. (Security-as-Code, Apache-2.0)
- [Toast](https://eiac.dev/katalog/toast): Konteneryzowane środowiska dev i CI definiowane w YAML. (SDLC / Policy-as-Code, MIT)
- [Tokens Studio](https://eiac.dev/katalog/tokens-studio): Design tokeny w narzędziu projektowym, synchronizowane z Git. (Design-as-Code, MIT)
- [Trivy](https://eiac.dev/katalog/trivy): Skaner podatności: kontenery, zależności, IaC i sekrety. (Security-as-Code, Apache-2.0)
- [TruffleHog](https://eiac.dev/katalog/trufflehog): Wykrywa i weryfikuje wycieki poświadczeń w repo i nie tylko. (Security-as-Code, AGPL-3.0)
- [Vault](https://eiac.dev/katalog/vault): Zarządzanie sekretami, szyfrowaniem i dostępem — z kodu i API. (Security-as-Code, BUSL-1.1)
- [Velero](https://eiac.dev/katalog/velero): Backup, przywracanie i migracja aplikacji Kubernetes oraz wolumenów. (App-as-Code, Apache-2.0)
- [Warpgate](https://eiac.dev/katalog/warpgate): Self-hostowany bastion/PAM dla SSH, HTTPS, MySQL, Postgres i Kubernetes — z SSO, RBAC, 2FA i nagrywaniem sesji. (Security-as-Code, Apache-2.0)
- [Watchtower](https://eiac.dev/katalog/watchtower): Automatyczna aktualizacja działających kontenerów do nowych obrazów. (SDLC / Policy-as-Code, Apache-2.0)
- [Winglang (Wing)](https://eiac.dev/katalog/winglang): Zorientowany na chmurę język programowania — infrastruktura i logika runtime w jednym modelu (preflight/inflight). (App-as-Code, MIT)
- [Woodpecker CI](https://eiac.dev/katalog/woodpecker): Prosty, rozszerzalny silnik CI/CD — pipeline'y jako kod, self-hosted. (SDLC / Policy-as-Code, Apache-2.0)

## Strony
- [O projekcie](https://eiac.dev/o-projekcie): manifest Everything Is A Code i pięć filarów.
- [Blog](https://eiac.dev/blog): wszystkie artykuły.
- [Katalog](https://eiac.dev/katalog): otwarte narzędzia „as-code".
- [Graf powiązań](https://eiac.dev/graf): mapa zależności między artykułami.