Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Hell froze over: announcing FormKit for React. Secretly framework-agnostic since inception, today we’re open sourcing the most popular Vue form library…for React. Why is this a big deal? 1. Forms are still hard. We (the creators of FormKit) thought form libraries were no longer necessary, given the trajectory of...

11,705 Aufrufe • vor 6 Monaten •via X (Twitter)

16 Kommentare

Profilbild von Corbin Crutchley
Corbin Crutchleyvor 6 Monaten

Finally!! Haha. I remember you telling me some time ago when this was being cooked up. Welcome to the React forms realm! 😄

Profilbild von Mostafa Said
Mostafa Saidvor 6 Monaten

Congrats to the React ecosystem on this gem👑

Profilbild von Chase Giunta
Chase Giuntavor 6 Monaten

Nice! I don't care for React, but hopefully this sparks some more usage & Pro $$$

Profilbild von uptonking
uptonkingvor 6 Monaten

for NO.6 schema, do you support it seems popular and futuristic

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

No, we have our own well established one at this point:

Profilbild von Corbin Crutchley
Corbin Crutchleyvor 6 Monaten

@uptonking2 FWIW, while I'm a strong proponent of Standard Schema and have integrated it into TanStack Form, FormKit's is much more flexible. Think of it less as a strict schema and more of a serializable programmatic instruction set IIRC

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

@uptonking2 This is accurate. And hi 👋

Profilbild von Alexandru Bucur
Alexandru Bucurvor 6 Monaten

Still a vue user but hopefully more people will use it, now can we get reactive rendering? :p

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

Oh? Like what?

Profilbild von Alexandru Bucur
Alexandru Bucurvor 6 Monaten

Had some issues when schema + data had to be dynamic and we forced a v-if to re-render the form 😅 I think there's a GitHub ticket saying that is not reactive somewhere

Profilbild von Adam King
Adam Kingvor 6 Monaten

Using the same FormKit component for the wrapper form and all inputs seems like an anti-pattern. Have you considered instead using `FormKit.Form`, `FormKit.Repeater`, `FormKit.Text` etc. instead? It would improve readability imo.

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

Why would it be an antipattern? It's literally how native html works: <input type="text"> <input type="checkbox"> <input type="number"> FormKit smooths out that api to encompass things like <select> and <button> too.

Profilbild von Adam King
Adam Kingvor 6 Monaten

There are two reasons, in my mind: 1. HTML intentionally has a different element for <form> than it does for <input> (and groups of inputs). 2. It's more difficult to reason about component structure at a glance if the same component is used for forms, groups, and inputs Perhaps you would consider at least enabling: <FormKit.Form>, <FormKit.Input>, and < That said, I still think it would be a better DX in React to use FormKit.Text, FormKit.Checkbox, etc. for inputs as well, because React is often scanned visually for top-level components. Your brain only has to pay attention to the props of a specific component if you are diving into a deeper level of abstraction. It's also important to think of how humans (and coding agents) will use the API in practice. Just because the documentation or recommended use of the component is to have the `type` prop directly after the component name, doesn't mean it will be used in that manner. Thinking about it this way, it's easy for developers to footgun themselves by placing the `type` prop later in the props chain, causing readers to have to read the entire prop chain just to understand what a specific formkit component will render as. Using the FormKit.{Element} format prevents this footgun entirely and preserves the at-a-glance scanability of component trees.

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

If thats a footgun you're concerned about you can wrap them. FormKit doesn't care about component depth, so you can very easily wrap a <FormKit type="form"> as <MyForm> or whatever you want. In practice this has not been a concern for users of FormKit, but again, the flexibility lets you solve the sugar easily.

Profilbild von Jay Ghiya
Jay Ghiyavor 6 Monaten

Does this work with tanstack forms? BTW thankyou

Profilbild von Justin Schroeder
Justin Schroedervor 6 Monaten

Totally different approach to forms than tanstack forms. Im sure you could get them working together, but they are really quite different. Tanstack forms is great too though :)

Ähnliche Videos

Bash is all you need! Which is why I'm introducing my holiday project: just-bash just-bash is a pretty complete implementation of bash in TypeScript designed to be used as a bash tool by AI agents. Because it turns out agents love exploring data via shell scripts, even beyond coding. It comes with grep, sed, awk and the 99th percentile features that an agent like Claude Code or Cursor would use. In fact, Claude Code can use it for secure bash execution. In the package - A bash-tool for AI SDK - A binary for use by yourself or your coding agents - An overlay filesystem to feed files to your agent securely - A Vercel Sandbox compatible API, so you can quickly upgrade to a real VM if you need to run binaries - An example AI agent that explores the just-bash code base using just-bash - I imported the Oils shell bash compatibility suite and just-bash passes a very good chunk What is interesting about this codebase: It was essentially entirely written by Opus 4.5. Coding agents love bash and they are good at reproducing it. They are also great at text-book recursive descent parsers and AST tweet-walk interpreters. That said, it is, like, a lot of code and I didn't read it all 😅. This is very much a hack, but it also seems to be _really_ useful. I haven't really found anything agents want to use that it doesn't support and it's fast and secure (caveats apply). It doesn't have write access to your computer and the filesystem is given a root that the agent cannot escape from. Find it at Related: Our recent blog post how we migrated our data analysis agent to bash tools and achieved incredible quality improvements The video shows the example agent investigating the just-bash code base

Malte Ubl

125,326 Aufrufe • vor 10 Monaten

Most AI coding setups right now look something like this: one agent in a terminal, another in a browser tab, a chat window somewhere else, and you in the middle copy-pasting diffs like a very tired air traffic controller. JetBrains just launched something aimed right at that mess. It's called JetBrains Air, and it lives inside their IDEs. The short version: Air lets you direct multiple coding agents, run their tasks in parallel, and review their work without ever leaving your IDE. Here's what stood out to me: 👇 1. You pick the agents. Air isn't tied to a single agent or provider. You can use the ones you already like. That matters more than it sounds, because the "best" coding agent changes every few months, and nobody wants to rebuild their whole workflow each time. 2. Parallel work without losing track. You can run several agent sessions at once, even across different projects. Air shows you where your attention is needed, so you're not hopping between tabs to find out which agent is stuck. 3. You stay in control. You can follow what each agent is doing, give it input, inspect the changes, and review the output before accepting anything. Nothing lands in your codebase just because an agent felt confident. 4. The agents get IDE smarts too. This is the part I find most interesting. JetBrains IDEs already have great code navigation, refactoring, testing, and debugging. With Air, both you and your agents work with that context. So the agents aren't guessing blind inside a chat box, and when something needs a human, the real tools are right there. The bigger idea here is that agents become part of your development workflow instead of a separate chat you keep switching to. There's also a nice bonus. For a limited time, JetBrains is offering Junie Lite for free (fair use applies). It's their own coding agent paired with a highly efficient model. It isn't pitched as a frontier-level agent. Think of it as a solid, free baseline for trying out Air and running everyday tasks. Air works in any JetBrains IDE and is in early access right now. If you write code with agents, give it a try: #ad

Mushfiq Sajib

40,469 Aufrufe • vor 19 Tagen

WHAT IS AN AI "SOFTWARE FACTORY" AND IS IT HYPE (31 MINUTE BREAKDOWN) I think it's a silly name for a genuinely USEFUL idea! A software factory is 5-6 markdown files that sit next to your code and tell your agents how you like to work, so you can build high quality apps 24/7. It's going viral because AI coding has a trust problem. The model can build the feature, but with no structure around it you end up babysitting the agent, wondering what changed and hoping it didn't break something important. So you build with agents the same way a factory builds physical products! 1. Each feature gets its own station, which in software means its own branch, so multiple agents can work at the same time without stepping on each other. 2. The build station gives the agent rules for how to write the code, because "it works" is very different from "a developer could open this repo next month and understand what happened." 3. The proof station makes the agent show evidence. Screenshots, videos, speed numbers, before-and-after states. It has to prove the thing works instead of saying it works. 4. The review station runs the work through a code review agent, and if it doesn't clear the bar, it goes back through the line. 5. Then you show up at the end to merge. For a 100+ years people have run production this way, and it worked because the structure is good. The full episode on what’s a software factory is NOW live on The Startup Ideas Podcast (SIP) 🧃 with the wonderful Micky Watch: So is it hype?!? I don't think it is, because of what it does to your output! WITHOUT a factory, you build ONE feature at a time and you're the bottleneck at every step, prompting, checking the diff, testing it yourself, hoping nothing else broke (spoiler alert it often does). WITH a factory, EACH feature runs in its own isolated copy of the app, so you can have 10+ of them going at once, and each agent has to prove its own work and pass a code review before it ever reaches you. Instead of supervising the work, you're APPROVING finished work that already has evidence attached. REALLY interesting to see how work with agents is evolving to be….well, similar to working with people!

GREG ISENBERG

32,056 Aufrufe • vor 1 Monat