This article reads like more of an ad than anything else.
> Environment variables only deliver values
Yes, the problem .env files try to solve is having "environment variables" be injectable from a file so that different applications can have different environment variables by default.
> A string is not a schema
Yes, input validation is an application concern. The application should know what these values represent / how to parse them and error if they're invalid.
I could go on, but the article is all about trying to use a hammer as a screwdriver and complaining that the hammer doesnt work.
jt2190 1 hours ago [-]
> Yes, the problem .env files try to solve is having "environment variables" be injectable from a file so that different applications can have different environment variables by default.
This seems like a misunderstanding: The `.env` file should be `source`d into the current shell (environment). The application reads values using whatever mechanism it uses to read these values from the environment. Nothing should be “injected” into the application, i.e. the application should not read `.env` directly.
(Not sure if you were just being loose with your terminology, trying to clarify.)
throw-the-towel 53 minutes ago [-]
Does it matter whether the app reads `.env` directly though?
e12e 50 minutes ago [-]
Maybe. How does the application unify different environment variables? Those inherited by the shell, those read from .profile, those set in the process that start the application (be that ./run.sh, a nodejs script, systemd etc...).
ramses0 11 minutes ago [-]
I wish there was better support for something like `SECRET_CMD="..."` (ie: "run this command to get/refresh secrets"), but that's just baking arbitrary command execution into your development pipeline.
Personally, I tend to have a `source ./source-me-auth` which does stuff like `DB_PASSWORD="$( pass show blah.com | head -1 )"`, but that still means I end up with secrets dangling around in my environment. The "source-me" file is safe to share, but my runtime environment is tainted (for good and bad...).
I saw something w.r.t. the way open-claw handles things where you basically say `export DB_PASSWORD="REDACTED@SECRET_001"` and then it basically outbound filters network requests to hydrate that with `s/REDACTED@SECRET_001/$REAL_SECRET/g`, and I _really_ like that mechanism b/c it defers secret usage to runtime and keeps it physically "out" of the application itself.
Basically, having `with $SECRETS -- some_app.sh --some params ...` wouldn't be terrible (conceptually).
eigencoder 4 days ago [-]
Hm, I haven't seen these issues personally. We only have one `.env` file and it's just for local secrets. Configuration emphatically does not go in `.env` and ideally is in docker compose and defined in code (we use Pydantic Settings).
The issue is that agents need structure and context.
preommr 1 hours ago [-]
No it isn't.
Your local .env should NOT be shared, but should also be assumed to be leaked at any given time. Security should be done using a secrets manager through the cloud platform that's being used, e.g. AWS'secrets manager (or ssm param store too i guess)
Pasting it into chatgpt should not be a problem.
It also doesn't belong in git repos, but a much bigger issue is what process led to it. It's pretty standard to ignore it in a .gitignore, I'd be very surprised if modern agents made that mistake. And even if they did, agents should call tools that scaffold deterministically so that this isn't a problem.
I genuinely don't even know what we're talking about anymore, .env files are just values (it even says so in the article). People are making it way more complicated than it needs to be for no discernable reason other than an insane amount of laziness.
tp3358 2 hours ago [-]
Yeah, this is the way. I assumed that was fairly standard at this point.
wonger_ 32 minutes ago [-]
I'm working with .env and secrets and teamwide configs for the first time, trying to understand solutions from first principles.
Are these valid observations so far?
- .env is the simplest and oldest / most boring solution. Secrets are passed to teammates by DM?
- .env.example seems like a nice home for documentation about secrets
- but I'd rather avoid writing sensitive credentials at all -- instead, teams can use a cloud-based secrets manager and the project fetches secrets at runtime. Is this ever a hassle / any downsides? How standard is this practice these days? I hear this also helps updating secrets so you don't have to e.g. tell every teammate when you rotate a secret. Generally not a fan of introducing a network call and a saas dependency, tho
- non-sensitive environment variables also need a home. I don't like the idea of cluttering the project with a .env.local or worse like .env.development.local
- I hear lots of secrets and config management happens in container orchestration, but what if I barely have a container in the first place? I guess docker compose is one of the simplest tools at this layer?
I guess I'm just looking for a safe, simple solution for a small team, and maybe the problem is that every team does things differently, and that many tools are marketed towards huge enterprise teams.
theozero 4 days ago [-]
Over at varlock (https://varlock.dev -- also free, open source), we agree that .env as we know it is full of problems. But instead of abandoning it, we evolved it. We replace your .env.example with a .env.schema - using decorator style comments to add schema info, and functions to load and compose values.
A big difference between our tool and many other similar tools is that we combine the schema and value setting into one surface, with a way of merging many definitions together, much like cuelang - but in a way that feels more intuitive. It's extremely flexible, and can even do credential brokering for untrusted workloads.
I've been enjoying the secretspec content lately, and watching it evolve :)
cyanregiment 4 days ago [-]
It's too bad they call background services "agents" now instead of daemons like they used to, because your slogan could be Secrets for daemons
Varlock is clever. Sub string types for .envs pretty cool, why not
That's what we are using as well in our small team. `mise` for our non-sensitive values/ environment variables and then `fnox` (from the same author) to encrypt and manage the secrets.
`mise` has a plugin for `fnox` that allows to automatically load the secrets in the context when running a mise task/command.
This way, our secrets are never exposed, even during local development.
Setting this up was effortless. Pretty happy about these tools.
kstrauser 4 days ago [-]
Seconded. I've also had great luck with the same author's fnox secret manager, especially because you can tell it to fetch some secrets from the user's laptop's OS keychain, and some out of 1Password, and some out of AWS KMS, and some out of [probably your own favorite provider (https://fnox.jdx.dev/providers/overview)].
domenkozar 4 days ago [-]
fnox is mostly a copy of secretspec (and it's good to have one!),
so you'll find the same kind of support in both. I wish instead we'd collaborate with Jeff, but oh well.
The difference is that we're providing an interface for applications to build with, with 8 SDKs available so you can have first-class support for secrets whatever you're bulding. I do hope fnox copies that too!
kstrauser 4 days ago [-]
You keep saying that but I disagree strongly. Having looked at both fnox and secretspec, there are some obvious similarities because they're both in the same space, interacting with many of the same tools, and there are only so many ways to declaratively state "set the FOO variable with the 'my_secret_key' value out of the Bar provider".
Those inherent similarities aside, I don't see it. They don't seem to have a lot in common as far as design or implementation or configuration.
ctippett 4 days ago [-]
I'm sure there are many better alternatives to .env, but its ubiquity and support across various tools makes it super convenient.
I'm using 1Password's .env integration[1] and although the UX is a bit clunky, I really like it. My API keys are secure, tools that ordinarily support
.env just work and there's a team-sharing feature too (although I'm yet to use it). It's pretty neat.
This is why I love direnv (the tool) and just a simple .envrc (not .env). It has none of the problems posited in the OP's article. It assumes nothing, only that direnv manges loading up the .envrc into your shell.
LeBit 53 minutes ago [-]
I moved from direnv, asdf and Task combo to mise.
Mise env vars management is much better. If you really need a script to generate env vars (like what you can do with direnv, there is a clean mechanism for that).
If you need to do something when you enter the directory of a project, there is also a mechanism for that.
Type "dotprot" to copy your .env file into 1Password using the 1P CLI, it verifies it's there, then deletes the local copy of .env. When you're ready to work again, type "dotprot" again to restore the .env file from 1P. There is a .prot file in the directory that you can declare other files to store in 1P as well.
Varlock (https://varlock.dev ) is also good for this and more mature. I use it on some work projects, but for local dev, I wanted something to allow me to be even lazier than that.
jpitz 28 minutes ago [-]
If 1Password hadn't jumped the subscription model shark, I'd be all over that. Any chance you'd entertain supporting bitwarden?
1 hours ago [-]
weinzierl 1 hours ago [-]
I see many .env files with unquoted values, like the first example in OP
REDIS_URL=redis://localhost:6379
and it triggers me big time. Always quoting shell variable values is so deeply ingrained from very painful experiences decades ago that it still causes a somatic flashback whenever I see it.
This is what went wrong with .env
Yes, I know
docker --env-file
doesn't work with quotes but that's just docker being broken and why they fixed it in docker compose.
It may be time for Hackernews to integrate a Pangram detector into the UI, similar to what substack is doing :)
jpitz 25 minutes ago [-]
Why should HN pay for a questionable service when it already gets crowdsourced results for free?
devmor 1 hours ago [-]
I’m not saying whether I think you’re right or wrong, but AI text detectors don’t work and never will.
chis 1 hours ago [-]
This has been pretty well studied. Pangram is about as good at an expert human with a 98% detection rate and <2% false positive, for flagging AI generated text.
Doesn't stop charlatans from creating startups promising to make it work :)
throw-the-towel 55 minutes ago [-]
I can't understand for the love of me why our industry settled on env as The Way to store configuration. It's poorly discoverable, it's a shared namespace polluted by everyone and their `libdog`, it's stringly typed, etc. All of that just flies in the face of otherwise accepted dev wisdom.
I love Django's approach to configs: your config is just a plain old Python file with some constants. As simple as possible, and works great.
e12e 47 minutes ago [-]
Worst part they're too easy to accidentally check in to source control - and they bring user/workstation dependent settings into the work tree, rather than tuck them away in something like $HOME/. config/appname/local.env
qntty 4 days ago [-]
I use Pydantic Settings for this, would be nice to see a comparison to that. I do like the idea of keeping this in a configuration file.
But secrets are a kind of configuration, right? I agree they should be kept separate from non-secret config; ideally non-secret configuration can be committed to your codebase somewhere depending on the environment it's running in.
tomjakubowski 4 days ago [-]
pydantic-settings is not limited to loading from config files. It is easy to populate a settings model from environment variables, for example. With a little bit of glue code it could load from the secretspec sdk.
triyambakam 4 days ago [-]
Yeah Pydantic Settings is pretty nice
KevinMS 3 days ago [-]
> Where .env Went Wrong
start with making it a dot file. Why would you want to hide the fact your app was using loaded environment variables?
s_dev 3 hours ago [-]
The fact that it's hidden means it doesn't get commited by accident in most git repos unless explicitly added or configured that way.
deathanatos 57 minutes ago [-]
No, it won't.
~/code
» cd foo
~/code/foo
» git init
± foo:main:/
» touch .env
± foo:main:/
» git add .
± foo:main:/
» g s
On branch main
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: .env
± foo:main:/
»
File is added, kaboom. "It should be in .gitignore" yes, true, but that has nothing to do with it not getting committed because it is hidden.
And even with it in .gitignore, I've dealt with multiple security incidents where someone has managed to commit it anyways. (And yes, I'm aware there are commands to do this, but what I haven't figured out is why someone would work around the safety and not think "what's the point of this?" prior to the bullet ending up in the foot.)
fhn 2 hours ago [-]
there shouldn't be any secrets in it so committing it shouldn't be a huge problem.
jerf 3 hours ago [-]
I hate that it's hidden too. There's no reason for it to be hidden and arguably some reason for it not to be hidden.
I did discover one reason for it not to be just "env" though, which surprised me, which is that "source env" will yield "bash: source: /usr/bin/env: cannot execute binary file". I did not expect the source command to use the $PATH to resolve the filename. Probably some minor security issues that can result from that out there in the world. Arguably anyone loading it should use "source ./.env" or equivalent, with full path.
It's documented in the bash manual, of course. But it is rather complicated as to when it will and will not use $PATH.
Brainspackle 3 hours ago [-]
You can easily use comments in the file for guidance, eliminating half your complaints
This was really popular, and lots of people bought the factor III of only configuring via environment variables.
The whole point of it was: keep config simple. Env vars are austere and will keep you from complexity.
But people found a way to complicate them, so they could have both the 12 factor literal pass and the complexity they wanted.
That resulted in the mess we are today.
Natfan 4 days ago [-]
Claude, find a key underpinning of most development workflows, then make a product to disrupt (and eventually SaaSify/enshitify) it. Finally, write a convincing ad disguised blog post, and purchase a fancy domain. Here's my credit card.
domenkozar 4 days ago [-]
Don't take the black pill <3
2 hours ago [-]
theozero 4 days ago [-]
While there are absolutely a million of these env tools popping up which are total vibe-coded slop, secretspec is not one of them. It's from the creator of https://devenv.sh and has been around for a while.
.env files are fine, as long as you don't import a random dependency to open and read a file. If you think about it for ten seconds, it's unjustifiable, and it's only done because others do it.
tosti 4 days ago [-]
One could also... Not jump on the bandwagon?
(Am I getting thrown out the window now? :)
hagbard_c 4 days ago [-]
The Doppler effect on your last words seems to confirm you just did.
nirbendavid 2 hours ago [-]
[flagged]
daniel_mcsoft 2 hours ago [-]
[flagged]
saadyousfi 3 hours ago [-]
[dead]
Rendered at 18:15:35 GMT+0000 (Coordinated Universal Time) with Vercel.
> Environment variables only deliver values
Yes, the problem .env files try to solve is having "environment variables" be injectable from a file so that different applications can have different environment variables by default.
> A string is not a schema
Yes, input validation is an application concern. The application should know what these values represent / how to parse them and error if they're invalid.
I could go on, but the article is all about trying to use a hammer as a screwdriver and complaining that the hammer doesnt work.
This seems like a misunderstanding: The `.env` file should be `source`d into the current shell (environment). The application reads values using whatever mechanism it uses to read these values from the environment. Nothing should be “injected” into the application, i.e. the application should not read `.env` directly.
(Not sure if you were just being loose with your terminology, trying to clarify.)
Personally, I tend to have a `source ./source-me-auth` which does stuff like `DB_PASSWORD="$( pass show blah.com | head -1 )"`, but that still means I end up with secrets dangling around in my environment. The "source-me" file is safe to share, but my runtime environment is tainted (for good and bad...).
I saw something w.r.t. the way open-claw handles things where you basically say `export DB_PASSWORD="REDACTED@SECRET_001"` and then it basically outbound filters network requests to hydrate that with `s/REDACTED@SECRET_001/$REAL_SECRET/g`, and I _really_ like that mechanism b/c it defers secret usage to runtime and keeps it physically "out" of the application itself.
Basically, having `with $SECRETS -- some_app.sh --some params ...` wouldn't be terrible (conceptually).
https://x.com/0xPrajwal_/status/2084163731534311627
https://x.com/nilbuild/status/2084339074639200488
The issue is that agents need structure and context.
Your local .env should NOT be shared, but should also be assumed to be leaked at any given time. Security should be done using a secrets manager through the cloud platform that's being used, e.g. AWS'secrets manager (or ssm param store too i guess)
Pasting it into chatgpt should not be a problem.
It also doesn't belong in git repos, but a much bigger issue is what process led to it. It's pretty standard to ignore it in a .gitignore, I'd be very surprised if modern agents made that mistake. And even if they did, agents should call tools that scaffold deterministically so that this isn't a problem.
I genuinely don't even know what we're talking about anymore, .env files are just values (it even says so in the article). People are making it way more complicated than it needs to be for no discernable reason other than an insane amount of laziness.
Are these valid observations so far?
- .env is the simplest and oldest / most boring solution. Secrets are passed to teammates by DM?
- .env.example seems like a nice home for documentation about secrets
- but I'd rather avoid writing sensitive credentials at all -- instead, teams can use a cloud-based secrets manager and the project fetches secrets at runtime. Is this ever a hassle / any downsides? How standard is this practice these days? I hear this also helps updating secrets so you don't have to e.g. tell every teammate when you rotate a secret. Generally not a fan of introducing a network call and a saas dependency, tho
- non-sensitive environment variables also need a home. I don't like the idea of cluttering the project with a .env.local or worse like .env.development.local
- I hear lots of secrets and config management happens in container orchestration, but what if I barely have a container in the first place? I guess docker compose is one of the simplest tools at this layer?
I guess I'm just looking for a safe, simple solution for a small team, and maybe the problem is that every team does things differently, and that many tools are marketed towards huge enterprise teams.
A big difference between our tool and many other similar tools is that we combine the schema and value setting into one surface, with a way of merging many definitions together, much like cuelang - but in a way that feels more intuitive. It's extremely flexible, and can even do credential brokering for untrusted workloads.
I've been enjoying the secretspec content lately, and watching it evolve :)
Varlock is clever. Sub string types for .envs pretty cool, why not
The difference is that we're providing an interface for applications to build with, with 8 SDKs available so you can have first-class support for secrets whatever you're bulding. I do hope fnox copies that too!
Those inherent similarities aside, I don't see it. They don't seem to have a lot in common as far as design or implementation or configuration.
I'm using 1Password's .env integration[1] and although the UX is a bit clunky, I really like it. My API keys are secure, tools that ordinarily support .env just work and there's a team-sharing feature too (although I'm yet to use it). It's pretty neat.
[1] https://www.1password.dev/environments
Mise env vars management is much better. If you really need a script to generate env vars (like what you can do with direnv, there is a clean mechanism for that).
If you need to do something when you enter the directory of a project, there is also a mechanism for that.
Mise is really nice.
Type "dotprot" to copy your .env file into 1Password using the 1P CLI, it verifies it's there, then deletes the local copy of .env. When you're ready to work again, type "dotprot" again to restore the .env file from 1P. There is a .prot file in the directory that you can declare other files to store in 1P as well.
Varlock (https://varlock.dev ) is also good for this and more mature. I use it on some work projects, but for local dev, I wanted something to allow me to be even lazier than that.
This is what went wrong with .env
Yes, I know
doesn't work with quotes but that's just docker being broken and why they fixed it in docker compose.Also see jt2290's comment:
https://news.ycombinator.com/item?id=49171684
It may be time for Hackernews to integrate a Pangram detector into the UI, similar to what substack is doing :)
https://arxiv.org/pdf/2501.15654
I love Django's approach to configs: your config is just a plain old Python file with some constants. As simple as possible, and works great.
- Secrets don't belong in config https://secretspec.dev/blog/secrets-dont-belong-in-config/
- You want to have flexibility of choosing between any secrets provider: https://secretspec.dev/blog/but-i-use-sops/
start with making it a dot file. Why would you want to hide the fact your app was using loaded environment variables?
And even with it in .gitignore, I've dealt with multiple security incidents where someone has managed to commit it anyways. (And yes, I'm aware there are commands to do this, but what I haven't figured out is why someone would work around the safety and not think "what's the point of this?" prior to the bullet ending up in the foot.)
I did discover one reason for it not to be just "env" though, which surprised me, which is that "source env" will yield "bash: source: /usr/bin/env: cannot execute binary file". I did not expect the source command to use the $PATH to resolve the filename. Probably some minor security issues that can result from that out there in the world. Arguably anyone loading it should use "source ./.env" or equivalent, with full path.
It's documented in the bash manual, of course. But it is rather complicated as to when it will and will not use $PATH.
https://12factor.net/
This was really popular, and lots of people bought the factor III of only configuring via environment variables.
The whole point of it was: keep config simple. Env vars are austere and will keep you from complexity.
But people found a way to complicate them, so they could have both the 12 factor literal pass and the complexity they wanted.
That resulted in the mess we are today.
(Am I getting thrown out the window now? :)