←
Gabriela Moreira1,894 posts
Gabriela Moreira avatar

Gabriela Moreira

@bugarela

CEO for @quint_lang because I care about software too much | Born and living in Brazil 🇧🇷

◷ Joined July 2018▧ 173 Photos and videos
Gabriela Moreira avatar
Gabriela Moreira@bugarela·Sep 2

We considered many shapes for the Quint product. We experimented a lot. It's time to put something out into the world! Waitlist link below

2:03
Gabriela Moreira avatar
Gabriela Moreira@bugarela·Nov 16

Did you know that Quint Studio is a local tool and you don't have to send us any data?

How does Quint Studio actually work? Short version: it runs on your machine, next to the coding agent you already use, and checks every change that touches the behavior you modeled. The longer version ↓

Post attachment
Gabriela Moreira avatar
Gabriela Moreira@bugarela·Nov 12

I'm watching @poteto's talk from yesterday and this part caught my attention as she talks about useEffect being often misused and "you need a PhD to use useEffect". You know what also has several parts that are often misused and that people say you need a PhD to use it? TLA+ (I'm thinking of the CHOOSE operator as one example). We were very worried about preventing misuse when building Quint because we wanted any dev to be able to use it. There are way more static anatalysis checks in Quint than for TLA+. Lamport built TLA+ for mathematicians and people as smart as him. It requires a lot of nuance to work well. Agents are not good at nuance! They are not really mathematicians, you know. We've been experimenting with new checks inside Quint Studio to keep specs generated by agents to good standards. I feel like this is a promising direction 💜

Post attachment
Gabriela Moreira avatar
Gabriela Moreira@bugarela·Nov 12

I had an amazing time chatting with Rachel on this episode 💜 check it out!!

On episode 61 of Generationship, @rachelchalmers speaks with Gabriela Moreira (@bugarela), co-founder and CEO of @quint_lang, about building trust in AI-generated code. Gabriela explains how executable specifications help engineers explore software behavior and why passing tests can offer false reassurance. They discuss making formal methods more accessible while preserving the judgment and curiosity that good engineering requires. hubs.ly/Q04F3C2D0

0:31
Flop Labs avatar
⟳ Gabriela Moreira retweeted
Flop Labs@flop_labs·Nov 11

With codebases rapidly growing, gaining different (and reliable) perspective is very important. Quint Studio definitely delivers on that!

Quint Studio is now in open beta! Here’s how it works in a minute. Studio breaks your codebase into components, agents write a Quint spec for each, real bugs get reproduced as tests, and your specs are kept in sync as the code changes.

1:18
J P avatar
⟳ Gabriela Moreira retweeted
J P@Jacob_Parece·Nov 11

Type checked TLA+ 😜 Quint Studio now open beta! The visualization of this studio really helps form better mental models. Give it a try!

Quint Studio is now in open beta! Here’s how it works in a minute. Studio breaks your codebase into components, agents write a Quint spec for each, real bugs get reproduced as tests, and your specs are kept in sync as the code changes.

1:18
Quint avatar
⟳ Gabriela Moreira retweeted
Quint@quint_lang·Nov 11

Quint Studio is now in open beta! Here’s how it works in a minute. Studio breaks your codebase into components, agents write a Quint spec for each, real bugs get reproduced as tests, and your specs are kept in sync as the code changes.

1:18
Quint avatar
⟳ Gabriela Moreira retweeted
Quint@quint_lang·Nov 10

We’ve been gnawing away at something important... Keep an eye out, it's almost ready!

Post attachment
Quint avatar
⟳ Gabriela Moreira retweeted
Quint@quint_lang·Nov 9

The community that got us here is the best part. Thank you all ⭐

0:12
Telegram Man avatar
⟳ Gabriela Moreira retweeted
Telegram Man@telegram_man·Nov 7

AI agents are getting better at finding holes in the software we use every day. The same technology could make formal verification practical at a scale that once sounded absurd. Thibault at OpenAI argues that we’re heading through turbulence toward much more secure systems. Formal correctness proofs for tens of millions of lines of code no longer look like a crazy idea. I’ve tried Logic-Driven Development myself. It takes longer upfront than telling an agent “build me an app.” But in my experience, the result behaves much closer to what I intended, and fixing one bug is less likely to break something elsewhere. Take an online store. A customer has 500 rubles and buys something for 400. The rules: charges must be positive, cannot exceed available funds, and must never leave the balance negative. A test confirms that a 400-ruble purchase works. But two simultaneous orders might both see a balance of 500 and both charge 400. A formal model describes the system’s states and transitions. A checker looks for a sequence that breaks an invariant, such as “the balance never goes negative.” You can catch the broken logic before writing the implementation. There’s a catch: concurrency and strange inputs must be included in the model. The checker won’t discover scenarios you never represented. I used Quint for this. My workflow now would be: write the rules with an agent, turn them into a model, have another agent look for holes, then simulate and check it within defined bounds. Use the model to generate test sequences with expected results. Only then write the implementation and run those tests against the real code, alongside unit and integration tests. Agents handle precise rules well. They have much less guessing to do than with a vague spec. But checking a Quint model does not prove the finished code is flawless. You still need to check that the implementation matches the model; strict proofs about the code itself require additional tools. Starting this way is easier than rebuilding existing applications. But it looks like old software will have to meet new standards too. Stock up on tokens.

Post attachment
Shaw avatar
⟳ Gabriela Moreira retweeted
Shaw@shawmakesmagic·Nov 6

TLA+ has been incredibly useful, even on brownfield project, for turning implicit state machines into explicit specs where the entire flow can be tested and verified. There is a deep relationship between user journey, UX flow and formal specification that has an enormous amount of value to slop code. I wanted something more programmer-y and Typescript-y, and I came across Quint. It's highly agent friendly and seems to be maximally useful for this new paradigm of programming. github.com/quint-co/quint Quint is high level, like TLA+, and doesn't formalize Typescript functionality. So underneath that, lower level, is Lemmascript. lemmascript.org/ This lets you markup your Typescript with contracts. The combination of these two things makes Typescript feel more like a compile time checked language, more verifiable, stronger guarantees, and it finds different kinds of bugs than AI generated unit tests seem to. It's not a magic bullet but damn it does seem to improve code quality a lot. And the agents can rapidly iterate against it. I think we're gonna see a lot more of this kind of thing popping up, especially in interpreted languages like TS and Python. I'd recommend using Quint when you're just modeling your application and flows (although I've been installing it into an existing project with good results) and then telling your agent to add Lemmascript in the build phase.

Brandon Kase avatar
⟳ Gabriela Moreira retweeted
Brandon Kase@bkase_·Nov 6

New skill for catching edge cases and surfacing product decisions before your agents code! * Ones that you didn’t realize (even when you rambled to your agent) * Ones that your agents didn’t realize (even after a grilling session interviewing you) This is my new go-to planning workflow for ui/ux features. It makes me confident my agents will handle these edge cases in ways that I expect and have reviewed. The secret: Don’t just formally verify your existing code. You can formally verify your hifi mockups with statecharts and @quint_lang too. Learn more about this in our latest Superlinear episode. And paste the GitHub link below to your agents to try it.

Post attachment

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05