Ethereum Developer Onboarding with Austin Griffith

Episode Description

Austin Griffith discusses Ethereum developer onboarding, Scaffold-ETH, Speedrun Ethereum, BuidlGuidl, developer experience, and smoother Web3 application design.

Episode Summary

Austin Griffith explains his work in Ethereum developer relations, focusing on tools and education that help builders move from Solidity basics to working decentralized applications. He describes how frustrations with early Truffle-era workflows led to Scaffold-ETH, an integrated environment for rapidly iterating on contracts and front ends, testing permissions, and progressing toward production. He outlines Speedrun Ethereum’s challenges, including NFTs, staking, token vendors, dice games, decentralized exchanges, and multisigs, as a way to teach Ethereum’s capabilities and mental models rather than syntax alone. The conversation also examines developer experience, the distinction between providers and signers, anonymous adoption metrics, and BuidlGuidl’s incentives for improving starter kits and tutorials. Griffith discusses EVM-compatible networks and Nifty Ink’s use of sidechains, burner wallets, and meta-transactions for onboarding artists, then recommends learning JavaScript, building small projects, and optimizing for shipping.

Speakers

Noah Hein
Anthony Campolo
Austin Griffith

Chapters

00:00:00 - Austin Griffith’s Role in Ethereum Developer Education

Anthony Campolo opens the Twitter Space, and Noah Hein introduces Austin Griffith. Griffith describes himself as a developer advocate for Ethereum who concentrates on onboarding, tooling, and concise curricula for people entering Web3. His goal is to reduce frustration so developers can build without learning every protocol detail first.

Griffith says he found this role by building games, applications, tutorials, and experiments around burner wallets and meta-transactions. The work became meaningful when other developers used his tools and created projects with them, giving him a practical measure of impact beyond simply publishing content.

00:03:34 - From Clunky Ethereum Tools to Scaffold-ETH

Griffith recalls discovering smart contracts around early 2017 after working deeply with Docker and infrastructure. Existing Ethereum development workflows, including Truffle and web3.js, felt difficult to configure, so he built Clavis, a Solidity compilation and deployment orchestration layer, alongside an early front-end toolkit called Apparatus.

As Hardhat emerged from Nomic Labs, Griffith adopted it and reconsidered his own tooling. That evolution produced Scaffold-ETH: a coordinated environment where contracts, deployment artifacts, and a React front end work together. The discussion frames better tooling as a response to concrete developer pain, not merely a preference for another framework.

00:06:33 - How Scaffold-ETH Accelerates Contract Iteration

Griffith explains Scaffold-ETH as a Web3 starter kit that works out of the box for hackathon and application development. Hardhat compiles and deploys contracts, while generated artifacts connect to a front end containing useful components. Developers can change a mapping, redeploy, and immediately inspect the result in the application.

The workflow also makes security assumptions tangible. Builders can test owner-only functions, transfer logic, required statements, and burner-wallet interactions by switching between accounts and trying both successful and failing paths. Griffith argues that this rapid feedback helps developers answer design questions about mappings, structs, and events before they commit to a production architecture.

00:10:49 - Framework Flavors and the Curriculum’s Purpose

Anthony Campolo asks whether Scaffold-ETH will remain React-based. Griffith says the project should offer multiple flavors rather than prescribe one stack, pointing to Vue, Vite, a possible Svelte direction, and a headless version. He also discusses the ecosystem around Ethereum hooks, Foundry, RainbowKit, Next.js, and Wagmi as tools developers were adopting in 2022.

Noah then asks how curriculum fits alongside tooling. Griffith distinguishes application-level education from protocol engineering: developers need a high-level understanding of what Ethereum is good at, but they do not need to implement an Ethereum node. Speedrun Ethereum is designed to teach that application perspective through hands-on challenges.

00:13:42 - Speedrun Ethereum’s Application Challenges

Griffith presents Speedrun Ethereum as a curriculum built from mentorship sessions and practical challenges. It starts with the tooling, then asks learners to write Solidity themselves while building applications that expose Ethereum’s distinctive properties. The first major exercise is a staking application that coordinates financially unrelated participants through explicit rules.

He lists later projects including an NFT, token vendor, dice game, decentralized exchange, multisig, and more advanced SVG-based NFTs. The sequence teaches syntax through concrete use, while also showing where randomness, trust, withdrawal logic, and adversarial behavior matter. His aim is to help learners understand Ethereum’s design space rather than memorize language constructs.

00:17:38 - Teaching Ethereum’s Mental Model

Noah praises the curriculum for connecting Solidity syntax to the kinds of applications Ethereum can support. Griffith says the central task is correcting the learner’s mental model: newcomers often treat Ethereum as an expensive asynchronous database or ask questions that assume conventional web architecture.

He uses a recurring cron-job example. A Web3 equivalent needs more than a scheduled process; the contract must enforce who can check in, the rules must be open for others to execute, and incentives must reward the desired behavior. Griffith’s conclusion is that Ethereum applications are largely about writing enforceable rules and designing incentives around them.

00:21:45 - Developer Experience as a Creative Constraint

Noah asks whether better developer experience matters especially on open platforms, where users may tolerate friction if incentives are strong. Griffith acknowledges that people sometimes mint NFTs through block explorers, but argues that confusing tools still damage creativity and obscure the underlying model.

He contrasts providers and signers in ethers.js. A provider reads from the chain, while a signer authorizes messages or transactions; separating them enables read-only access before a user connects a wallet. Anthony describes this as engineering a “pit of success,” and Griffith adds that tools should remove error-driven frustration so builders can stay focused and creative.

00:27:03 - Measuring Open, Anonymous Education

Anthony connects the discussion to developer-experience engineering, and Noah asks how Griffith measures success. Griffith says Scaffold-ETH and Speedrun Ethereum are intentionally open and anonymous: learners can use burner wallets and sign messages without surrendering email addresses or entering a paywall.

That philosophy makes measurement difficult. Scaffold-ETH had been forked more than 2,000 times, but Griffith could not know how many downstream applications still used it. He watches completion and drop-off signals, yet considers personal reports from builders who found work or launched products especially meaningful. He connects this measurement problem to BuidlGuidl’s incentives for builders and the evidence needed to show funders the work’s impact.

00:33:11 - From Eth.Build to an Incentivized Builder Community

Griffith traces BuidlGuidl’s origins to Eth.Build, a visual dashboard for combining blockchain data and logic blocks. When that approach did not have enough impact, the Ethereum Foundation encouraged a pivot toward Scaffold-ETH, which made it easier to tinker with Solidity and connect contracts to applications.

The BuidlGuidl followed as people forked Scaffold-ETH and created specialized starter kits. Griffith compares this to leaving a campsite better than it was found and says teaching a concept back is a powerful way to learn it. Contributors could document tools such as CREATE2, publish clearer repositories, and receive ETH incentives for improving the ecosystem.

00:36:28 - BuidlGuidl as Signal, Portfolio, and Public Good

Griffith characterizes BuidlGuidl as more than a reward program. It gives him ground-level signals about developer needs, frustrations, and the direction of a future Scaffold-ETH release. It also acts as a public-good mechanism: funding flows toward builders producing educational material and prototypes on Ethereum.

He says participants can build a visible portfolio covering decentralized exchanges, multisigs, NFT experiments, tools, or new versions of the learning platform. In 2022, Griffith described the Guild as supported by the Ethereum Foundation and organized as a DAO associated with a Wyoming LLC. New members entered through early Speedrun Ethereum challenges and continued through Guild projects.

00:38:34 - EVM Networks and Nifty Ink’s Onboarding Strategy

Anthony asks about chains beyond Ethereum. Griffith calls himself an EVM maximalist because the surrounding tools and skills transfer, while emphasizing that sidechains and other networks can make application-specific sense. He uses Nifty Ink as an example of a product that could not provide its intended onboarding flow directly on Ethereum mainnet.

Nifty Ink used a cheaper network then known as xDai, later Gnosis Chain, along with burner wallets and meta-transactions. Artists could create and mint work without first understanding seed phrases or acquiring ETH for gas. The approach lowered the initial barrier while preserving a path for valuable assets to move toward Ethereum. The goal is to let artists gain value before asking them to manage keys and protect their assets.

An audience member asks whether social authentication could make decentralized applications approachable to artists and non-developers. Griffith supports a progressive-decentralization model in which users might begin with Twitter-based access and later move to Ethereum accounts, provided the experience avoids another conventional email-and-password system.

He warns that a platform-controlled custody arrangement must clearly explain its risks. If a database fails, users may not control their assets or recover them. Griffith favors a gradual path from platform-managed access to self-custody, with the product making that transition and its tradeoffs understandable rather than pretending the initial login is equivalent to a user-held key.

00:45:57 - Future Speedrun Challenges and Builder Matching

A listener who has completed nearly all Speedrun Ethereum challenges asks what comes next. Griffith says the curriculum could add more challenges, including an order-book exercise potentially aligned with recruiting needs at a company such as 0x. He also points learners toward a BuidlGuidl “next steps” list.

Beyond formal challenges, Griffith matches advanced speedrunners with artists and teams that need builders for projects such as new NFT experiences or public-goods funding mechanisms. The Guild therefore becomes a bridge from exercises to real collaborations, while also helping developers build portfolios and find practical opportunities.

00:50:10 - Advice for New Builders and Closing Discussion

In the closing turns, Griffith recommends that non-programmers first learn JavaScript fundamentals and React, then build a small product they will personally use. After that, he directs them to Speedrun Ethereum for Solidity and application-specific mental models, followed by projects that present a real challenge.

His central advice is to optimize for shipping rather than perfection. Griffith recalls publishing imperfect experiments during “Bow Tie Fridays” and encourages builders to make small things, share them publicly, and learn from what resonates. Noah thanks the participants, and Griffith closes by inviting listeners to reach out and continue with Speedrun Ethereum.

Episode Links

The Space lookup was unavailable when the archive was assembled; its announcement and transcript are preserved.

Transcript

This automatic transcript retains the original timestamps and wording apart from clear name corrections. It may contain transcription errors or turns that combine speakers.

00:00:00 - Anthony Campolo

We are here, we can hear you. The Twitter is spacing.

00:00:06 - Austin Griffith

What's up, what's up, what's up, what's up?

00:00:09 - Noah Hein

Hey. Welcome Austin. How are you, sir? Doing great. How are you? Oh, man, I am fantastic. my. I live in Austin. I just got a bunch of rainfall, so everything is looking decidedly less desert y. and all of the grass is green. There are literally birds chirping outside my window. It's, very picturesque.

00:00:32 - Austin Griffith

yeah. I got my lawn in Colorado looking right. Lots of rain.

00:00:38 - Noah Hein

Awesome. So, I think a lot of people here that are already joining I know may know you already, but I'll just hop straight into it. If you could give everyone here, just like your quick background and what it is that you do in your day to day, that would be great.

00:00:54 - Austin Griffith

Awesome. Yeah. So I, I would say that I am a dev rail for Ethereum I think a lot about developer onboarding and developer tooling, and I want to make sure who devs who come into this space and want to learn about Web3 have a good, quick to the point curriculum and good tools that are easy to use and not very frustrating.

00:01:18 - Austin Griffith

I got into the space like building games and kind of building weird things, but my work didn't really start resonating with the ecosystem until I started building tools and showing those tools off. So it's kind of become kind of the niche that I have. I've landed in is tool building and developer education.

00:01:39 - Noah Hein

Yeah, I'd be curious to hear. So it sounds like, you know, very, you know, typical developer education developer relations stuff. but how did you wind up, you know, finding out that you liked doing this specific job? And how did you wind up working for the Ethereum Foundation? Is there a story to tell there?

00:02:00 - Austin Griffith

I think so. I just like building things that people use, right? So I'm always trying to find like product market fit in a way. For my tools or my apps or my games or anything I build. And I just after building tools and building tutorials and, you know, I enjoy teaching, kind of after building those things, they just got a lot more traction in the space.

00:02:25 - Austin Griffith

I started talking about things like meta transactions, and I started talking about things like burner wallets and those kind of like pushed the boundaries of of how people are interacting with apps. And that to me, like it just felt good. I enjoyed it and it seemed to have impact in the space. And so just like getting getting content out to people and having people build things and then seeing what they built and seeing people use the tools is, is personally rewarding to me.

00:02:55 - Noah Hein

Yeah, no, I definitely resonate with that on unlike seeing the work that you're doing, that's actually kind of how I wound up doing, like blockchain related things, as I was like looking for a job, doing different, you know, developer blog stuff, just writing about what I was learning. And I made some posts that was like related to Ethereum and doing blockchain stuff, and I saw that it just exploded. And that was like still relatively recently for me. So I've been doing this for a little over a year. when is it that you started? I know you've been doing this for a while, so could you kind of speak to, like, what tools or content were out there whenever you had just started building?

00:03:34 - Austin Griffith

So, yeah, like, I was deep down the rabbit hole on Docker for a long time and building infrastructure and code and building even like, scalability layers around Docker.

00:03:46 - Austin Griffith

So I missed early Ethereum. I think it was about it was probably early 2017 when I discovered smart contracts, and I really fell in love with what you would do with smart contracts and what it means to build a decentralized app. But I think that the, the thing. Let's see. So I got into the space basically writing. I built a couple games, and the best tools you could use at the time were pretty clunky. I was using, you know, I tried using truffle, and it didn't really work. I think maybe, like, DApp DApp tools were around them, there weren't a lot of great tools. I think web three.js was probably around then. So after building my own project, I realized, like, there's a, there's there's a huge opportunity here to just build better tooling and have better tutorials. So I built my own orchestration layer similar to truffle. It used soul C, it was called Clavis, and Clavis used soul C to compile contracts. And it was basically just a wrapper around soul C so you could do compiling and then orchestrating.

00:04:56 - Austin Griffith

So you could, you know, deploy a bunch of contracts you would set up, like, here's my contracts. I want to compile all them. I want to deploy them in this order. And this is kind of how you orchestrate the stack. And and then I had apparatus on the front end that would receive those artifacts. And it was like a front end with a bunch of handy components, like an address field and an, you know, address input. So like very early in the day, I started using truffle in web three.js. It was very frustrating. I built my own, but they didn't really like catch on. But I used them a bunch of times for a bunch of different builds and then eventually, like Hard Hat came out and I adapted. I adopted that, and then I realized like, okay, I don't need Clovis anymore because I have hard hat, I still have this apparatus. I saw this idea of DApp building, and that's what led to scaffold and kind of having this kind of all in one package that allows you to tinker with your smart contracts, but then have a front end that deploys with it.

00:05:54 - Austin Griffith

So yeah, the short answer tools in the space were not great. You had really clunky development environments. Something would go wrong every time when you tried to set up truffle. So I tried to build my own, but they weren't that great. And then, you know, someone came along and that's Nomic Labs with hard hat and made a better version of it, and I was able to adopt that into my stack.

00:06:19 - Noah Hein

Yes. So I'd be really curious, like, what is scaffold piece for anyone who who hasn't used it? Like what is, you know, a 10,000 foot view?

00:06:28 - Anthony Campolo

Also, apparatus is the best name ever. Throw that out there.

00:06:33 - Austin Griffith

Yeah, that's. I feel like that's probably one of my. My biggest superpowers is like, naming stupid shit, but, Yeah. So scaffold eath is, going leaning into the fact that if you're going to set up a Web3 development environment, it's going to be super complicated. There's going to be a couple different tools that have to work together and you're going to get these weird errors.

00:06:57 - Austin Griffith

So with with scaffold eath, the goal was to have a DApp starter kit that works out of the box. If you're at a hackathon and you're thinking about building a specific tool that does something, you want to focus on that tool. You want to write the smart contract, and then you want to kind of like build that the front end to kind of talk to the app. But scaffold eath makes that really, really easy because it comes with hard hat. And when you compile and deploy from hard Hat, the artifacts are injected into a Create React app that's full of a bunch of components that you're already going to need. And there's this there's a specific, kind of iteration loop you get in where you have your smart contract and you make a small change to it, and then you deploy that. There's kind of a quick little yarn deploy. You do, and you deploy that into the front end. And then your front end auto adapts. So you add a mapping over in your smart contract, and then your front end shows that mapping.

00:07:55 - Austin Griffith

And then you kind of kind of like check the balance of someone and you're like, okay, now we build a transfer function over in the solidity. Then we go back over to the react, and we try using the transfer function to send back and forth. And then maybe we create an only owner require statement over in our smart contract. And then we quickly jump over to the app and we make sure the owner can set it. And then we, you know, create an incognito window that has a burner wallet. And then we set it and make sure a bad guy can't. So it kind of helps you, like test the happy path, the bad, the sad path. It helps you test your required statements. It helps you like tinker with solidity and just get a feel for how you want your app to work with without being able to go into smart contract development with like a just a very clear picture of what you're building, you almost need to iterate, and you need to tinker with the language and figure out, you know, is this going to be an array of structs or is this going to be a mapping? Are we going to use an event here? There's there's a lot of questions you kind of answer as you're building, and scaffolding just helps you get to those answers quicker.

00:08:56 - Austin Griffith

I see Carlos out in the crowd. He and I are working on a curriculum, and we started the curriculum by just writing scripts. And we noticed that like, yes, you go to your smart contract and you put in a required statement that says only the owner can do this, but then to like even interface this with that or have it like solidified in your mind that that requires statement is doing what it needs to do. You then spend another ten minutes writing a test that makes sure the owner can do it, and then you spend another five minutes writing a test to make sure the owner you know, someone who's not the owner can do it. Whereas with scaffolding you get like this really raw, visceral. You know, try it as the owner, try it as someone who's not the owner and just tinker with it and test your assumptions. So it just gives you a quick front end to be able to tinker with your solidity early. And then as you build out your app and you create, you know, a more advanced product, you kind of carve out some of that scaffolding and you kind of build out a production level app.

00:09:54 - Austin Griffith

So scaffolding isn't just for getting started, but it really will accelerate your, your, your time in terms of getting started. And you'll have something that can be a production level app when you're ready with things like subgraph and a lot of other like, production level things. So I don't want to like lean too far into it's just a starter kit to get started. But it will it will both accelerate your getting started and also help you get to production faster.

00:10:21 - Anthony Campolo

Yeah, I've really enjoyed getting to check out scaffolding because I was building out like very, very similar types of projects in terms of the the stack you were using. And then I found this and I was like, oh, this dude already built the thing I wanted. And so I was like, super happy to see that. I was curious though. Do you think it's always going to be react based? Do you think there may be like a different version that could be like view or sculpt based, or is that something you're not really too interested in to want just to hone in on like the react kind of front end.

00:10:49 - Austin Griffith

So definitely we need we have lots of flavors, right? We don't want to be too prescriptive about how this thing works. We just want people to be able to quickly experiment and build things out. So of course we're going to have, you know, some a couple of other flavors here. There's even things like we have eath hooks in scaffold eath, which is just a ton of handy hooks that help you build out your app. Things like use block number, use contract reader, use contract loader. That that eath hooks library is now basically what Wag Me is like. Basically Wag Me did that exact same thing. So whether or not like they copied us or whatever, like it doesn't matter. That seems to be like the library. That's that's catching on. So I feel like we should just carve eath hooks out of scaffold eath and have wag me in there. And we see things like foundry coming out where it's it seems to be getting a lot of traction and more developers are using it. It kind of seems like the hot thing.

00:11:45 - Austin Griffith

So I feel like there's this version of there's kind of like version two of scaffolding. There's probably something more like foundry, rainbow Kit, Wag Me and Next.js. We see a lot of people using Next.js, so I feel like 100% open to other flavors. If you go to scaffolding and you go to the repo, there's already like eight different flavors of it. I think there is a view. I think there's a vite. I don't know if we have a svelte version. I don't think we do. But we're also working on like a headless version. Or then we could stack, you know, other different, UI component libraries on top of it. So 100% open to, different flavors, but even more so, I think we should really lean into what, what is the hot stuff that everybody is using right now. And let's make a quick DAP template with that hot language. And I think that is probably like foundry, rainbow Kit and Next.js, but also just like open to other flavors. I'm just trying to figure out what developers want and make sure we have that starter kit ready for them.

00:12:45 - Anthony Campolo

Yeah. That's cool. I'm starting to mess around with some some svelte kit web. Three examples this next week, so I may push some upstream to you at some point.

00:12:55 - Austin Griffith

Sounds awesome. I think Wiggle Wag has one called, jolly Roger that's built in svelte. And also anytime I hear svelte, I want to say whoever svelte it dealt in. It's a fun, fun little run.

00:13:12 - Noah Hein

So, I would be curious. So that's like a lot on, like, the developer tooling and obviously, like, if you want a developer ecosystem to grow, you need to make developers productive so that they don't have to learn, like literally every single thing about the language, just like people that are running eath nodes don't need to know, like how geth works, you know, 100% like they don't need to, you know, read the yellow paper and go implement it themselves. where does like, the whole curriculum and content come into play for you?

00:13:42 - Austin Griffith

So the curriculum, is it basically is for application level stuff, right? You don't need to know, like at a protocol level, how this stuff happens.

00:13:50 - Austin Griffith

But you do need to know, like what Ethereum is built for and what it's not good at, right? So at some level, it's nice to know a little bit of the protocol high level stuff. But the curriculum for me is about building applications. And it starts with speedrun Ethereum. Com so if you're interested in learning scaffold ETH, you're interested in building decentralized apps. Go to speed run ethereum.com. And it's it's a quick curriculum that's based on hundreds of hours of mentorship sessions where we've created these challenges that first walk you through using the tooling, but then, help you build decentralized apps, focusing on the smart contract. And it's not going to write it for you. You have to figure it out yourself. And there's there's definitely like, you know, if you feel like you're stuck in tutorial hell, you should take the speedrun Ethereum on because it's not going to hold your hand through the solidity. You're going to have to write the solidity yourself, and it's going to teach you what Ethereum is good at.

00:14:53 - Austin Griffith

The first real challenge is building a staking app and getting people who don't necessarily trust each other to be able to coordinate financially is one of the superpowers of Ethereum. And then on the other side of it, as the builder, it allows you to write a few simple rules and deploy that app in a way that anyone can access it from anywhere. And it's unstoppable, right? So, so being able to build an application that lets people stake funds on a certain thing, and then if they're able to stake enough funds, then you kind of move into a successful state. If they're not able to stake enough funds, they kind of move into a withdraw state, and you need to set it up so people can withdraw their money and people can't grief them. No one steals each other's money. Just building those rules. You're kind of building like a little vending machine and kind of getting people over that mental model and getting people to understand what you can and can't build on. Ethereum. Kind of starts with speed run Ethereum.

00:15:50 - Austin Griffith

It takes you all the way through, even like building your own Dex, building your own multisig. randomness is hard on chain. So we we take you through how to build a dice game and then how to kind of rig the dice game. So you win every time. So there's, there's just a lot of concepts that you need to cover first. I mean, first and foremost I'm rambling here. This is a Twitter space. It's for rambling. Probably first and foremost is about getting the syntax down. Right. So you as a developer will need to get the syntax of solidity, but it's super easy. Any good developer can pick up the syntax in literally like a few sessions of sitting down and going through mappings and functions and payable functions and structs and modifiers and all that. So that's at the top of speed run through. You go to speed Run Ethereum. It's like here's a video. And then here are the topics you need to learn real quick. You go learn those topics by basically just like grabbing things from solidity by example, pasting them into scaffold eath, testing your assumptions.

00:16:50 - Austin Griffith

And then it starts you with a challenges challenge. Zero has you mint your own NFT. Basically, you like create your whole NFT project by just following these instructions, and you mint them to a public network and you can send your NFTs around. So if you're just looking for a good template to mint NFTs and go try to get rich, you can basically stop at challenge Zero and never write any code. But then challenge one is a staking app. Challenge two as a token vendor. Challenge three is the dice game, challenge four is the Dex, challenge five is a multisig. And then we get into building like more advanced NFTs, like SVG and NFTs. And then there's a whole bunch of like, kind of secondary challenges that will stack on top of that. But you'll you'll have to get through the program to see what comes next. But speedrun, Ethereum, speedrun, Ethereum.

00:17:38 - Noah Hein

Yeah. And I've always been a really big fan of the approach that you took whenever building out the curriculum. Because I think it focuses a lot more on like to what you said on what Ethereum is good at and what it's not good at, because I think a lot of people are already developers and they say, hey, cool.

00:17:56 - Noah Hein

I want to learn solidity and they take like a 1 or 2 hour course that teaches them all of the syntax and solidity. Syntax is fairly straightforward. If you've written, like really any programming language, it's really easy to grok and pick up. But what you don't get is like what you're actually using it for. And that whole paradigm shift of, hey, this is not the same thing. Like you are obviously writing code and there's syntax and you know, there's if, if else loops. But whenever you actually start digging into it and you're like, okay, cool, I know about solidity. And then you like crack open like the Uniswap router or something like that, and you're just suddenly like completely overwhelmed. I'm like, whoa, this is something entirely different. I think Speedrun Ethereum does a really good job of like, hey, these are the kind of things that you want to build, and this is how you kind of put all of those pieces together to build something that is run successfully in an adversarial environment.

00:18:49 - Noah Hein

And I always really liked the, I heard you in a podcast talking about like, how to build a cron job and like, I thought that was like a really good example of like, hey, yeah, you could build this in like a normal web development way where this runs on a timer, but that kind of defeats the purpose of it. I'd be curious. like, how do you think of building these sort of curriculums? Like, what are the things that you want to show people how to build? Like what? How do you identify where the important Lego pieces are that people need to put together to put like, actual production apps into place?

00:19:24 - Austin Griffith

It's almost about like getting you over the mental model, like going back to when we see people first come in, they're using it like a database and they're like, okay, so I have this new expensive asynchronous database that I need to store things to, and I have this record of first name, last name, and we go through storing everything on the database.

00:19:42 - Austin Griffith

So it's maybe less about the mental model of getting to production and more about just like getting the mental model. Right. So you're even asking the right questions, right? A lot of times people will come in and ask like, how do I mine Ethereum so I can make some Ethereum. It's like, no, that's that's not the way to go. Like you're you're barking up the wrong tree. And we have to like teach you which trees to bark up. Basically, I think the the cron job is a great example of that. If you have a web developer and they understand what a cron job is, it's a process that needs to run periodically. They set up some service and that service runs in web three. It's it's yes, you need to have the service running. But really what you need to have there's there's two really important things here. You need to you need to write the rules correctly in the smart contract. So someone can only check in every 24 hours. And then you need to create incentives around that behavior so.

00:20:39 - Austin Griffith

So it's much less about having the technology up and running and more like the technology is always going to be up and running. If you can create the right rules and incentives to play on top of that layer. So it's just like that, that mental model shift from if I want a task to happen every night, I don't just write a piece of code that runs it every night. I need to write a piece of code that runs it every night, make it very open source so lots of people can run it and then correctly write the rules so only one person can check in and then correctly incentivize that behavior. So someone gets paid by doing that. And only then do you create a web three cron job where this is a thing that's going to run every night, guaranteed. And you did that not by creating some dope technology. The dope technology is already there. You did it by creating the right rules and the right incentives around those rules. And I think that's like an insight into almost everything you'll build on Ethereum is you need to correctly incentivize the behaviors that you're trying to achieve.

00:21:45 - Noah Hein

Man, I love that. And I think it's really indicative of something that I think is interesting. And I haven't heard too many people talk about, but I think you touched on it a bit whenever you started talking about, how scaffold eath kind of like teaches you on how to iterate and not only like, does it speed up your iteration process, it also kind of informs it to a certain degree. And I'd be interested to see if you thought or yeah, if you thought about really how like increasing developer experience actually is a little bit more important on, you know, open platforms like Ethereum versus, you know, something that's more traditional web development in the sense like, if you make this cron job a lot more difficult to actually pay where like a simple version would be like, hey, cool, you like click a button and it sends you some eath. ether. Whenever you click that button. You know it. When updated. Some things that needed to be updated. But you could make that process like arbitrarily more difficult by adding certain things.

00:22:45 - Noah Hein

Is that something that you think is like, particularly relevant, or is it just, hey, someone will find a way to click this button regardless of how hard it is if the incentives are in place.

00:22:56 - Austin Griffith

It's really weird. Like we see people minting NFTs using ether scan, right? And like my caveman brain says, no one's ever going to do that. And if you want to be successful, you need to have like, a really low barrier to entry. I do agree that, like, some things are just good enough, and I think that a lot of the giga brains that I talk to when I talk about Ethereum developer experience, and I say it needs to get better. A lot of the Giga Brains say people will work through it with the right incentives. Like people will just go through it. But but to kind of like really kind of nail down your point there. I've used tools that were frustrating to use and didn't give me a lot of good context. And I've used other tools almost like going back to like me growing up and using the the like the Mac operating system compared to other operating systems, I sort of like accidentally found out how to do a lot of things, and the tool like gave me a lot of context about like what we're actually doing here and what we're trying to achieve and what what the issues are and how I'm thinking of it wrong and how I need to be thinking of it right.

00:24:00 - Austin Griffith

Almost like if you look at web three.js for ethers JS, regardless of clunky ness, regardless of documentation, the way the tools are built, web three.js doesn't really differentiate between providers and signers. And so when I got into Ethereum, I was thinking they were all just like one thing. And I would go to MetaMask and it would be my provider and signer and everything. But as you get in and you start learning more about the space, you realize that they're very separate things. You sort of have this provider that's like a connection to the blockchain, and you have this signer that is signing these messages, you don't necessarily need to couple those things, and by decoupling them, you actually can build a much better website experience where someone is able to get in and have kind of a read only version and use just the provider at first, and then right before they need to make a transaction, then they need to start thinking about what that signer needs to do instead of having just like a walled gate that says you have to like basically sign in before you can see anything.

00:24:59 - Austin Griffith

And that that came from like a tool, right? That came from a shift in how the tool builder, Rick Mew was the guy who wrote or is the guy who writes ethers. JS and when I first started using ethers JS it was like frustrating. I was like, why the f are there signers and providers when it's all the same thing? And my mental model wasn't right yet, and I had to use the tool for a little bit.

00:25:22 - Unidentified speaker

To understand the difference.

00:25:23 - Austin Griffith

To then understand the real mental model, to then understand why I was even asking the wrong question in the first place.

00:25:29 - Anthony Campolo

And this is why people are giving developer experience as like, it's like this needs to be its own term. It needs to be its own thing. There's people who've even considered themselves developer experience engineers, because the amount of engineering you need to put into these tools to make them, like, we just have this term and the pit of success to the point we're like, we're gonna give you a tool. You almost have to, like, go out of your way to fail with it, to not have something built at the end of the day with it, because we're going to give you these guardrails are going to so specifically point you in the right direction.

00:25:59 - Austin Griffith

Yep. And not just like education, but also like taking the wind out of your sails. Like whenever, whenever I use a tool that that gets out of the way and lets me do something like lets me be creative, I'm just a lot more creative when I use a tool and I'm trying to be creative, and it's like throwing error messages and I'm getting frustrated like that. Creativity goes out the window immediately. Like anytime I use a get coin product, I completely lose my creativity because I'm so angry about how awful the user experience is right. You have to. If you want people to come and use your platform and be creative and and have that those juices flowing, there can be no anger, there can be no issues, there can be no problems. That thing has to work perfectly and be buttery smooth and let them just be creative. And as soon as you create any kind of speed bumps that that create, creativity will slip away.

00:27:00 - Noah Hein

I love that, and I think it's a recurring theme, certainly.

00:27:03 - Noah Hein

And like the whole like developer tooling and developer experience is just making is really getting out of the way as, as much as you can where it's like, hey, you want to do this thing? It's very straightforward how you can accomplish that task. And speaking of like, you know what success is among developer tooling. Like, how do you kind of like measure whether or not you're you're doing a good job whenever you're putting out these courses and, you know, writing these tools. Like what? What do you what makes you feel good at the end of the day, whenever you go to sleep?

00:27:36 - Austin Griffith

This is like kind of a hard problem because with scaffolding and everything we do, we want to be like anonymous first. We want anyone to be able to get in here and use this. And we're not tracking you. We're not getting our hooks in you and getting your email address. You can literally go to Speedrun Ethereum and it's Web3 native like Carlos is still in the audience. Like props to him for building it this way.

00:27:59 - Austin Griffith

It's basically you're using IP 712 signatures, and all of that is being stored in a database and everything, everything, even though it's in a database, it's all still Web3 because it's using your Web3 wallet and we're not requiring anything of you. There's no paywall. There's no there's no like sign up and give us your email and then you can get in. You can you can literally be completely a non sign it. You can create a burner wallet and you can sign a message with a burner wallet and start learning on Speedrun Ethereum. So first of all, this is a hard thing because we don't track anybody. specifically with scaffold eath, it's it's a starter kit that's been forked more than 2000 times. So there's 2000 versions of scaffold things out there. There's there's apps that use scaffold eath that I use on a daily basis that I probably don't even know was were built with scaffold eath. Right. There's there's so little hooks and things that I have no idea how many things are getting built. So a lot of this is like gut feeling, which is fine.

00:29:01 - Austin Griffith

But then like we need to start measuring like, is it, is it time to build scaffold eath to. Right. Are we waxing or waning in terms of users. Right. So we have some small metrics in terms of like just straight up how many people are getting through the program. Where are they getting hung up? Are they, you know, are they completing things. But we don't have like a great metric on on like how many people. But they're a metric of success for me is like when someone comes up to me and says, I did speedrun Ethereum, I built a few things and now I'm like, getting paid to work in the space, or I built a product and I quit my job. Like so. So seeing things get built is is a huge success for me. Seeing people be able to just fork scaffold heath and learn quickly and then build something on top of that is a huge success. Seeing seeing random people from all over the world be able to speedrun Ethereum without any walled garden is a success for me, but it's really hard to measure those successes.

00:30:06 - Austin Griffith

So that's like definitely a gray area. We're kind of like tinkering with right now when we talk about Build Guild and the incentivized layer around all of this, where, where then, you know, so so what's happening is basically you speedrun Ethereum and as you go through it, you know, I, I hooked you up with an INS name or something like that, I say. I say thank you a couple times with a little bit of teeth, but then you end up like either building something or not. And I want to incentivize that. So I create these streams of eath to developers that are building cool things. And then that means that we need funding for the Build Guild. So to show off, you know, you know, the success of the Build Guild, we almost need more of these metrics. We need to understand how many people are going through and using it, and how many people are building things, and we kind of don't track that kind of stuff. And so it's it's almost like a bit of an existential crisis right now of how we make a very, very open platform that anyone can fork and run with and we don't track.

00:31:09 - Austin Griffith

And also, how do we kind of prove that we are having a lot of impact? So that's definitely like still an open question.

00:31:18 - Noah Hein

Yeah. No, I totally get that. And I think that, you know, there is a certain degree of like, whenever someone walks up to you and says like, hey, I was able to speedrun Ethereum and now I'm doing X, Y, and Z. You know, you can you can kind of extrapolate a little bit on like, hey, what percentage of people are walking up to me and saying that and saying like, oh, maybe this person represents, you know, like x many people, but, you know, it definitely does get harder, especially whenever you start asking for funding. I imagine that is probably something that to to what you're just saying price struggles with. Whenever you say like, hey, this is like a well, I would consider a wildly successful product in the ecosystem. And like, yeah, lots of people are building on it.

00:31:57 - Noah Hein

But then someone asks you whenever you ask them to take out the checkbook and they're saying like, oh, well, how many, how many people are bidding on it? And how successful is it actually? And you're kind of like, well, I don't know, like the people walk up to me and tell me that it's great. you know, it's definitely something that I think a lot of people struggle with and is, you know, part of the space. And I wonder, like, how many like, companies that, aren't using, you know, sign in with Ethereum. This is like a really big one. Whenever I learned, like, just how easy it was to essentially authenticate a user into your website using sign in with Ethereum. But how many don't? Just for the sheer fact of like, yeah, I can't really track this, like one person could represent half of my users if they were just, you know, generating a new wallet every single time they signed into my app.

00:32:43 - Noah Hein

And like, I can't really track any of that. That's definitely interesting. and I know people are working on, like, the whole decentralized identity and everything in this space, but that's that's another rabbit hole that we don't have to to go down. I'd be curious, like you just started talking about Build Guild. what started Build Guild? Like, was it right after scaffold eath you just started this? Could you kind of give the origin story of Build Guild?

00:33:11 - Austin Griffith

Yeah for sure. I think that, so so it kind of started. So I'll even rewind a little bit to like eath top build. I started with eath dot build. It was it's a way for me to kind of teach the curriculum. It's not. It's like a dashboard builder. You can, like, drag and drop a blockchain and pull the block number out. And then if the block number is greater than something, you can execute on something. So it has all these like logic blocks you could put together, which made it really easy for me to use to explain just topics.

00:33:42 - Austin Griffith

So it started with these build. And each build was good, but it wasn't having a lot of impact and and kind of the, the like, like my boss at the time basically at the EFF was like, let's, let's pivot, let's do something new. And that's where scaffold eath came from. So scaffold eath was like, okay, like, let's make let's make the starter kit. Let's, let's get people straight to tinkering with solidity, and let's make it really easy for them to build a DApp around that solidity. And then we realized, well, this is this is a starter kit for starter kits. And then all these different other starter kits were coming out of that. Right. Like there could be an NFT starter kit, there could be a Dex starter kit. So so what I realized was people were forking it and making other really cool starter kits. And people were also, like, not fully through their education yet. They would get started and they would, they would there would still be some some distance they needed to cover.

00:34:38 - Austin Griffith

And so the Build Guild was about incentivizing folks to pick up scaffolding and build something new with it. I talk a lot about, when I was young with my dad and we would go camping, he would always say, you need to leave the campsite better than you found it. And I feel like with, with with scaffold, we're trying to, like, incentivize folks to leave the campsite better than you found it. And there's this other theme where if you really want to learn something, you teach it back, right? The first time you go learn something, sure. But then when you have to teach that thing, then you really learn it. So. So with scaffolding and with Build Guild, I'm trying to incentivize folks to pick up scaffolds and go learn a new topic. Let's say you've heard of create two. You know how create two kind of works, but you don't like have a solid understanding of it. You Google create two, right? You go to the campsite and the campsite is kind of messy and there's lots of things there and there's not a great answer.

00:35:34 - Austin Griffith

So then you sit down with scaffold and you build a create two starter kit and you make the readme very clear and it walks you through how to get how to get it up and running, how to tinker with it, how to do it. Create two deployment. How the salt works. Kind of just like what create two is and how it works. And then you leave that campsite better than you found it, right? You get that readme, you publish it and you put it up there. And then the Build Guild lets you withdraw eath to to publish that. So so then there's that's the build Guild is the incentivized layer. So leave the campsite better than you found it. Teach it back to other people. And the Build guild will will reward you with Ethereum for doing that. So there's kind of like these incentives baked in. And the Build Guild is kind of like It's it's an army of builders, but it's it's only a small subset. It's only a small cut of all the developers that are building.

00:36:28 - Austin Griffith

And like I said, it's very anonymous and we don't have everybody out there. So the Build Guild to me is also like this kind of like meta signal that helps me understand what are developers doing, where are they frustrated? What do they need more of? What what tools are they using? Like it gives me an idea just on the ground, one on one with a developer of what scaffold ETH 2.0 needs to look like. So the Build guild is an incentivized layer. It's a signal layer. It's almost like a public good where you can fund the build guild. And that money is going to go to developers that are building products, prototypes and tutorials on top of Ethereum. So it's kind of this nice little feedback loop. It's helping signal, it's a Dao. We the build Guild is known official Wyoming LLC Dao, and it's being supported by the Ethereum Foundation. So we've come a long ways from just being a simple little org, and we're starting to grow and bring in new builders. And if you would like to get into the Build Guild, if you're interested in this kind of stuff, you can just start at Speedrun Ethereum.

00:37:34 - Austin Griffith

You go to Speedrun ethereum.com, you take on those first three challenges and you get dropped into the Build Guild and the Build guild then is a place where you can build up your portfolio. You can see the portfolios of hundreds of other builders in the Build Guild. And you can see, yeah, they built a dex. Yeah, they built a multisig. But now they're building this cool like weird NFT project, or now they're building this cool tool, or maybe they're building scaffold ETH 2.0, or maybe they're building speedrun Ethereum. Right. So so the Build Guild is also a place for a developer to build up their profile and portfolio. So then like when you go to get a job, you can say, not only do I know solidity, but I know the mental model for Ethereum. And you can see my whole portfolio of all the things I've built that. That really show that off.

00:38:22 - Noah Hein

I love that, and before I next ask my next question, I'll go ahead and say, like, if anyone has questions, feel free to request to speak.

00:38:29 - Noah Hein

I'll bring you up here in a little bit, and ask questions.

00:38:34 - Anthony Campolo

But, Ben, I was I was curious, Austin, if you're ever working with like, EVM compatible chains that aren't Ethereum, and if you think any of those are kind of worth pursuing it for, like people who already have messed around a bit with Ethereum, or maybe looking to kind of expand out to other stuff while still retaining their, like, solidity, you know, skills.

00:38:56 - Austin Griffith

That's what it is. It's the skills, right? The skills and the tools. I, I joke that I'm an EVM maximalist. I'm not necessarily an Ethereum maximalist, but I'm an EVM maximalist just because that's where all the tools work. But I will I will say absolutely. Like we like NFTs blew up at a time where they couldn't all just live on Ethereum. And there's tons of use cases where side chains and alternate altos and or alternate L1 and L2 just made more sense. I will zoom in, particularly on building Nifty Inc. If you go to Nifty Inc. It's an NFT platform and it was something that we couldn't build directly on Ethereum.

00:39:37 - Austin Griffith

We wanted to build a platform where an artist could come in and make art without having to ever understand what a 12 word seed phrase was. And also without ever having to get eath. These are these are like really hard things in terms of onboarding. If you want to participate in an app on Ethereum, you need to have a wallet. You need to have a 12 word seed phrase backed up, and then you need to go spend money and get eath in that wallet to pay the gas. So we wanted to show how you could do that differently. And so we built Nifty Inc in a way that uses meta transactions and burner wallets and runs on a side chain. Used to be called XD, but now it's Gnosis chain, so the combination of a cheap side chain and then sign messages using meta transactions and then a burner wallet. Basically, we generate you a wallet when you land on the site. The combination of all three of those things create this really smooth onboarding for artists. So an artist can go to Nifty Ink, they can hit create, they can draw something really interesting and it records the motions of their drawing.

00:40:47 - Austin Griffith

That's kind of like the gimmick of Nifty Ink is it records you as you draw, and you can watch the process of someone as they make their doodle or their their artwork. But an artist can come in, they can draw something, they can mint an NFT on the side chain and we pay the gas. So they just sign a message with their burner wallet that they know nothing about at that time. And we pay the gas to mint. And these things, by the way, do upgrade to main net Ethereum. So if they built something, if they drew something really cool there that can go all the way to Ethereum if it's worth the money to upgrade it. But the key that we're zooming in here on is that an artist can know nothing about. 12 word seed phrases can know nothing about any of that stuff. They get in. They make something cool. They can even put it up for sale and sell it. And this is the magic right here is now that artists sells a piece of artwork and they make maybe $10 or $20 on this side chain.

00:41:43 - Austin Griffith

Now all of a sudden they have value. Either either they own some some artwork or they own some actual now like eath on this network at that point. Then the artist starts to say, okay, how do I protect this? What what is what is this account? What is this? And we've shifted we've kind of turned onboarding on its head. Right? Instead of the person being forced to learn a 12 word seed phrase before they can interact with anything, we basically give them value. We give them, we get them into their ecosystem. They provide value. They earn money and then they're like, absolutely incentivized to figure out that 12 word seed phrase. So it just makes the onboarding a lot smoother. And you couldn't do that on main net Ethereum. You could only do that on a cheaper side chain where we can pay the gas for you. So long story short. Absolutely. I'm all about like other EVM compatible networks. even competing ones I think are good for the ecosystem. I think it's good for application developers.

00:42:41 - Austin Griffith

So. So I'm all about it.

00:42:45 - Noah Hein

Awesome. And I see, Tisha. Go ahead.

00:42:50 - Audience member (Speaker 5)

hi. actually, I had, a thought to share and wanted to have Austin's thought on it. so, Austin, what do you think? like, in order to smoothen up the onboarding process. Like, if a person, as you rightly said, that, if we have the artist and they, they don't really know how to use wallets or they don't really want to store their the seed phrase somewhere. So what if we include the social authentication part in it? how do you think that will help us? And you know that social authentication we make somehow, like we include the decentralization part in it, but, like, give the feel of web two logins so that at least the person who are not developers or who just want to, you know, they are artists or someone else who don't have much knowledge about it. they can easily be onboarded onto the decentralized application. So what are your thoughts on it?

00:43:48 - Austin Griffith

I think for sure, I think you could do like a progressive decentralization thing where people could log in with their Twitter at first and they could.

00:43:56 - Austin Griffith

I'm putting air quotes around sign messages, but they could they could sign messages with their Twitter account. It wouldn't be like a key pair backed, but you could do things where it's still native to them. They sign in. The thing that I don't want is another email and password, right? If I go to the site and it asks me for an email and a password to be able to get in, like, absolutely not, that's out. I don't want anything to do with that. But if it gives me the option to log in, like either log in with my Ethereum address or log in with my Twitter, sure. Like I can log in with my Twitter at first and start building things, and then maybe I even accrue some value. And that goes into like a smart contract wallet that the platform is, is in like a non-custodial wallet at first. Right? They they custody your assets. They custody your wallet. You just use your Twitter at first. But yeah, as soon as you start earning value, you're going to start asking questions about like, well, who's really in charge? How do I and something we have to teach to like when you say that's a non custody wallet, people don't really understand that they could get like totally mugged by a database going down.

00:45:04 - Austin Griffith

Right. They don't understand the mental model yet. So somehow the product going back to the product user experience has to just be really clear and it has to, you know, make the mental model clear that, yes, like you were able to quickly on board. But there's, you know, kind of a giant asterisk here that like if, if this database goes down, you could lose your assets. Like you're not in full control of your, your assets yet. But you could slowly kind of, you know, incrementally get them to the point where then they can self custody. I yeah I'm all about that I think I think that's that's a good way to do it. Just know no username and password anymore please. Like let me at least single sign on with my Twitter and then eventually single sign on with my Web3.

00:45:49 - Audience member (Speaker 5)

Yeah, yeah. Really appreciate your thoughts on it. Thanks.

00:45:54 - Noah Hein

Cool. And, Reddick.

00:45:57 - Audience member (Speaker 6)

Hi, Austin. Loved what you love what you are doing. And I have a question about the future of, speedrun Ethereum because I've done, I think, practically all of the projects.

00:46:10 - Audience member (Speaker 6)

I have one left, I think multisig. And once it's done, I will have all the projects completed and even even like for myself. I would love to see more because it's been a ton of fun. But also just like for for the for everybody, for the community. What are your plans for speedrunning Ethereum other than potentially moving to like scaffold S2 or something like that that you already mentioned? yeah. Just wanting to to learn your, your plans for speedrun speedrun, which is fantastic, by the way. And congratulations and love speedrun Etherium hard.

00:46:49 - Austin Griffith

Sorry, sorry. Thank you. Yeah. I've seen you go through it, so I think so speedrun Ethereum next steps we would love to have I think you're still on speaker there. We would love to have more challenges obviously like we get people through, you know all the way through the decks and the multisig and then they're really they're really ready to start shipping stuff. It would be great if we added a few more challenges there. We may even add challenges that are specific to different recruiters.

00:47:15 - Austin Griffith

Like I was talking to Will from Xerox and we were talking about how we should just have an order book challenge as part of it. And if you go through the order book challenge, you're automatically like ready to go work at Xerox or something like that, right? So more challenges is is an area. Now if you're looking for more steps after taking on the challenges, there's a there's a next. Oh there's a next step button on on build guild. If you go to Build Guild there's like a link for next steps. And it's just like this giant tweet thread of things like great next projects. But the ultimate alpha here is that I'm always in chats and I'm always collab with all these cool artists. I have all these connections to all these artists that know that I'm a builder and want to build something, but don't have the builder to build it. And so what, what kind of happens is as you go through the speedrun and you join the Build Guild. I start. I start chilling out to do lists on my list.

00:48:15 - Austin Griffith

Right? There's this artist that wants to make an aging NFT. There's this artist that wants to make a sold out NFT that does this. There's this group that wants to build a public goods funding mechanism. So. So people are always reaching out to me for, you know, help building things. And so what I do is I grab speedrunners that are kind of toward the end of the speedrun, and I link them up with these folks. So there's a lot of like, you don't see it in the speedrun, but there's a lot of like next steps outside of the speedrun that are actually like you building projects on Ethereum for people. So so there are some next steps that are kind of external to speedrun Ethereum. I think speedrun Ethereum itself, we just need some more challenges. We need to cover a few more topics. We need to cover a few more things, just kind of keep filling in that mental model and making them fun. but really, it's go join, go join, build Guild and start being active more in the guild.

00:49:14 - Austin Griffith

Guild and be active in those chats. And I'm I'm yolo ING projects all the time into those build guild chats. Like, I think just this morning someone was looking to build something and it's like, all right, give me a quick description. All right. I'm going to copy and paste that description into a telegram. Then two different builders reach out about that. And then all of a sudden there's a private telegram of, you know, an artist and an engineer and a couple of my builders, and they're building out a project that's that's going to, you know, this is going to be awesome. So, so yeah, long, long winded answer there. I kind of recruit you out of speedrun to go build things. But also I would love to see more challenges built into the speedrun.

00:49:57 - Audience member (Speaker 6)

Awesome. Thanks. Thanks a lot. And yeah, it's a motivation for me to just finish that last challenge and see what's next.

00:50:05 - Austin Griffith

Keep building. Keep building.

00:50:10 - Noah Hein

All right. Cool. I don't have anyone with more questions.

00:50:14 - Noah Hein

So, Austin, why don't we wrap it up with, you know, for one, obviously people can find you here, but, what is your number one recommendation to new builders? I think I already know what it is.

00:50:25 - Austin Griffith

Yeah, yeah. Thankfully. So. So a long time ago, this was a hard question to answer. But now, thanks to Speedrun Ethereum, my answer is always go speedrun Ethereum. And and if you're if you're a brand new builder and you're not a programmer yet, I would say go take some JavaScript courses like go learn how to build a for loop, go, go learn how to write a little bit of react, build, build a simple little product that you'll use yourself. A good example is a to do list or a Web3 dashboard. Build something that you'll use and you'll iterate on yourself. Then once you kind of have that like knowledge down, then go speedrun Ethereum and go through learning the syntax and then go through all the challenges. Then there's kind of next steps.

00:51:11 - Austin Griffith

Find a project that it doesn't need to have to be even be like a novel project in this space, but a project that will challenge you. And there's a real important thing here. You need to get in the habit of shipping and get in the habit of shipping. Not a perfect product. On on Bowtie Fridays, I would put on a bow tie and I would hit record and I would ship the thing no matter what shape it was in. And sometimes it was better than others.

00:51:39 - Anthony Campolo

But that I say optimize for shipping. That's that's like I tried to boil it down to a phrase optimized for shipping.

00:51:45 - Austin Griffith

Yes, exactly. And don't be afraid of shipping and ship out loud. Show things on Twitter. So just get in a habit of making small things and putting them out into the world and being loud about them and see what resonates.

00:52:00 - Noah Hein

Awesome. Well, I appreciate you coming on Austin and for all of the listeners, thanks for coming and have a wonderful day, everybody. Bye.

00:52:08 - Austin Griffith

Thank you everyone.

00:52:10 - Austin Griffith

Great session. You can reach out anytime. DMs are open. Speedrun. Ethereum. Com.