> As developers today, we often know what we need to do but struggle with the how; [deplyment commands, permissioning commands] ... Foyle solves this problem by turning your intent into executable commands.
In my experience, no developers don't know what they need to do. They have an app that does stuff on their laptop. Between that and production they often have no clue.
Infra is plumbing, and plumbing is contextual details. These details are the very specific things that an LLM doesn't have access to.
The fact that there is a Palo firewall between two subnets means deploying your app isn't a kubectl away. The fact that DNS goes through another team means routing myapp.mycompany.com requires a jira ticket. Heck the fact that you use istio means ingress works completely differently.
The premise of Foyle is that you can solve this problem with runbooks that walk you through the steps to deploy your app; in this case setting up appropriate networking. Problem is no one wants to read or write documentation. So Foyle tries to learn by observing what commands people do. So in this case, an expert (e.g. someone on the infra/platform team) deploys an app or troubleshoots a networking problem and they do this by creating a notebook which contains some exposition and the commands. Foyle learns from this. So now when an app developer goes to deploy a new app, they start a document "Deploy Caribou" and Foyle starts suggesting the steps and commands to deploy it.
> Foyle is an AI that helps developers operate their software by using LLMs to translate intent into action.
> ...
> As developers today, we often know what we need to do but struggle with the how; [deplyment commands, permissioning commands] ... Foyle solves this problem by turning your intent into executable commands.
Honestly, this seems like the wrong solution to badly designed UIs. Either foundational UIs should be improved so people can actually use them, or a restricted but easier-to-use UI designed with a straightforward translation layer onto the foundational ones. "I don't know what I'm doing, so I'll use an LLM to give me commands I lack the competence to review," seems like a massive footgun.
There are some good ideas like here, like "Self-Documenting Operations: By capturing the intent (in markdown) and the actions (in code cells), Foyle creates comprehensive, executable documentation of your infrastructure operations," but they seem more like good commenting practice rather than what this is.
I'm the creator of Foyle. Why do you assume the user lacks the competence to review the commands? In order to execute the commands you need the relevant tools (gcloud, kubectl, etc...) to be installed and you have sufficient privileges. Why would you install and grant privileges to tools you don't know how to use safely?
Being able to review a command isn't the same as being able to author that command without errors. An obvious example is queries (e.g. SQL or Cloud Logging). I can easily know enough to be able to review them and decide a query is safe. That doesn't mean I can easily remember the precise syntax that each tool/system requires.
Is there a difference with a set of scripts that have been carefully reviewed and approved? Those scripts can have parameters, and use authentication to handle the different scenarios.
If a scenario is new, the sysadmins should handle that by changing the scripts or hide it in the CI. Again: approved and reviewed.
And if it hasn’t been approved AND you don’t know what you’re doing, you shouldn’t experiment on the infrastructure of the company and let professionals do their job. I don’t see the added value of Foyle here.
Also:
> As developers today, we often know what we need to do but struggle with the how
It’s false. I struggle with what I need to do, and that’s why I talk to product owners, bosses, architects, and employees. Once everything has been clearly defined, the solution is easier to implement. Engineering is about understanding what needs to be done and that’s the hard part.
> Is there a difference with a set of scripts that have been carefully reviewed and approved
I think Foyle is complementary. Creating a script/tool/higher level abstraction is valuable when you do the same exact task over and over. This is creating a so called "paved path". However, paved paths often limit flexibility. To optimize flexibility we often divide a task into composable tool chains. Foyle can help you compose these chains. So it can help you in instances where it doesn't make sense to create a bespoke tool because it wouldn't be used frequently enough.
People seem very negative about this in the comments. How is this worse than asking internal chat "how do I h.f. rem peak by constantly fromaging the bitumogenous spandrels?" and then pasting whatever response after checking it briefly for typos and sanity?
Especially when tools like git, ffmpeg, podman etc. each require separate degree in writing correct command line invocations?
> People seem very negative about this in the comments. How is this worse than asking internal chat "how do I h.f. rem peak by constantly fromaging the bitumogenous spandrels?
Because a free product someone else built with good intentions should work as well and easily as a product built by a multi-billion tech company, which steals your data and privacy in the background. Duh.
> As developers today, we often know what we need to do but struggle with the how; [deplyment commands, permissioning commands] ... Foyle solves this problem by turning your intent into executable commands.
In my experience, no developers don't know what they need to do. They have an app that does stuff on their laptop. Between that and production they often have no clue.
Infra is plumbing, and plumbing is contextual details. These details are the very specific things that an LLM doesn't have access to.
The fact that there is a Palo firewall between two subnets means deploying your app isn't a kubectl away. The fact that DNS goes through another team means routing myapp.mycompany.com requires a jira ticket. Heck the fact that you use istio means ingress works completely differently.
How does foyle address these kinds of issues?
The premise of Foyle is that you can solve this problem with runbooks that walk you through the steps to deploy your app; in this case setting up appropriate networking. Problem is no one wants to read or write documentation. So Foyle tries to learn by observing what commands people do. So in this case, an expert (e.g. someone on the infra/platform team) deploys an app or troubleshoots a networking problem and they do this by creating a notebook which contains some exposition and the commands. Foyle learns from this. So now when an app developer goes to deploy a new app, they start a document "Deploy Caribou" and Foyle starts suggesting the steps and commands to deploy it.
Why would an expert work towards making himself redundant?
> Foyle is an AI that helps developers operate their software by using LLMs to translate intent into action.
> ...
> As developers today, we often know what we need to do but struggle with the how; [deplyment commands, permissioning commands] ... Foyle solves this problem by turning your intent into executable commands.
Honestly, this seems like the wrong solution to badly designed UIs. Either foundational UIs should be improved so people can actually use them, or a restricted but easier-to-use UI designed with a straightforward translation layer onto the foundational ones. "I don't know what I'm doing, so I'll use an LLM to give me commands I lack the competence to review," seems like a massive footgun.
There are some good ideas like here, like "Self-Documenting Operations: By capturing the intent (in markdown) and the actions (in code cells), Foyle creates comprehensive, executable documentation of your infrastructure operations," but they seem more like good commenting practice rather than what this is.
I'm the creator of Foyle. Why do you assume the user lacks the competence to review the commands? In order to execute the commands you need the relevant tools (gcloud, kubectl, etc...) to be installed and you have sufficient privileges. Why would you install and grant privileges to tools you don't know how to use safely?
If you know how to use them then why would you need AI?
Being able to review a command isn't the same as being able to author that command without errors. An obvious example is queries (e.g. SQL or Cloud Logging). I can easily know enough to be able to review them and decide a query is safe. That doesn't mean I can easily remember the precise syntax that each tool/system requires.
Is there a difference with a set of scripts that have been carefully reviewed and approved? Those scripts can have parameters, and use authentication to handle the different scenarios.
If a scenario is new, the sysadmins should handle that by changing the scripts or hide it in the CI. Again: approved and reviewed.
And if it hasn’t been approved AND you don’t know what you’re doing, you shouldn’t experiment on the infrastructure of the company and let professionals do their job. I don’t see the added value of Foyle here.
Also:
> As developers today, we often know what we need to do but struggle with the how
It’s false. I struggle with what I need to do, and that’s why I talk to product owners, bosses, architects, and employees. Once everything has been clearly defined, the solution is easier to implement. Engineering is about understanding what needs to be done and that’s the hard part.
> Is there a difference with a set of scripts that have been carefully reviewed and approved
I think Foyle is complementary. Creating a script/tool/higher level abstraction is valuable when you do the same exact task over and over. This is creating a so called "paved path". However, paved paths often limit flexibility. To optimize flexibility we often divide a task into composable tool chains. Foyle can help you compose these chains. So it can help you in instances where it doesn't make sense to create a bespoke tool because it wouldn't be used frequently enough.
(I'm the creator of Foyle)
What's the difference between someone who can review a command and someone who can't? How do you know you have reached that point?
Is this your project? If so, we should make it a Show HN! https://news.ycombinator.com/showhn.html
i laughed out loud when i saw this page https://foyle.io/docs/getting-started/k8s/
>Prerequisites: VSCode & RunMe
>Foyle relies on VSCode and RunMe.dev to provide the frontend.
Well that’s a lot to take in, especially from a Mozilla project.
It's a Mozilla Future project in their Builders program's 2024 cohort: https://future.mozilla.org/builders/2024_cohort/
People seem very negative about this in the comments. How is this worse than asking internal chat "how do I h.f. rem peak by constantly fromaging the bitumogenous spandrels?" and then pasting whatever response after checking it briefly for typos and sanity?
Especially when tools like git, ffmpeg, podman etc. each require separate degree in writing correct command line invocations?
> People seem very negative about this in the comments. How is this worse than asking internal chat "how do I h.f. rem peak by constantly fromaging the bitumogenous spandrels?
Because a free product someone else built with good intentions should work as well and easily as a product built by a multi-billion tech company, which steals your data and privacy in the background. Duh.
Yep, the internet is one giant peanut gallery. Waldorf and Statler would be excited.