{"article":{"slug":"bad-ideas-that-arent-bad-anymore","title":"Bad ideas that aren't bad anymore","subtitle":null,"summary":"Devon C. Estes argues that AI coding tools are turning many long-standing software engineering 'bad ideas' into reasonable choices, and that leaders now need to adapt and learn quickly rather than lean only on past experience.","content_type":"essay","language":"en","canonical_url":"https://devonestes.com/bad-ideas-that-arent-bad-anymore","author":{"name":"Devon C. Estes","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"Devon C. Estes","url":"https://devonestes.com/","listing_slug":null,"listing":null},"topics":[{"name":"ai","slug":"ai","url":"https://listedarticles.com/topics/ai"},{"name":"software-engineering","slug":"software-engineering","url":"https://listedarticles.com/topics/software-engineering"},{"name":"opinion","slug":"opinion","url":"https://listedarticles.com/topics/opinion"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":2367,"reading_minutes":10,"published_at":"2026-11-06T00:00:00.000Z","added_at":"2026-11-12T08:07:00.269Z","updated_at":"2026-11-12T08:07:00.269Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/bad-ideas-that-arent-bad-anymore","markdown_url":"https://listedarticles.com/articles/bad-ideas-that-arent-bad-anymore.md","example":false,"citation":"Devon C. Estes, Devon C. Estes. \"Bad ideas that aren't bad anymore.\" 6 Nov 2026. https://devonestes.com/bad-ideas-that-arent-bad-anymore (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://devonestes.com/bad-ideas-that-arent-bad-anymore"},"body_markdown":"# Bad ideas that aren't bad anymore\n\n6 Nov 2026\nDevon C. Estes on\n[AI](https://devonestes.com/tag/AI)\n[Engineering](https://devonestes.com/tag/Engineering)\n[Leadership](https://devonestes.com/tag/Leadership)\n[Management](https://devonestes.com/tag/Management)\n\nI’ve been working in software for about 15 years now, and over that time I’ve made a lot of\nmistakes and learned from a lot of other people’s mistakes. This experience is a deep well that I\ncan draw from when discussing possible solutions for both technical and non-technical problems.\nThis is how I know what sorts of solutions sound good in theory but run into problems in practice,\nor what fringe idea is actually a perfect fit for the problem we’re trying to solve here. This\nknowledge & experience is a big part of what has made me effective as a leader.\n\nLately, though, a lot of the things my gut tells me are bad ideas are turning out to work really\nwell. In our team’s retro this week that hit me pretty hard, and it was a real learning moment for\nme. It made me realize that a big chunk of the intuition I’ve been relying on might not be worth\nas much as I thought anymore, and that I need to question that experience more frequently.\n\nSo I wanted to write down a few of the “bad ideas” that we’re doing right now that are actually\nworking really well, and then to try and figure out what that means for people like me.\n\n## Nobody reviews anybody else’s PRs\n\nFor pretty much my whole career, code review has worked the same way: one person writes the code\nand opens the PR, and then somebody else on the team reviews it before it gets merged. The second\nset of eyes catches bugs, spreads knowledge around the team, and keeps any one person from\nquietly drifting the codebase off in their own direction. Merging your own PR without review was\none of those things that was a “break glass in case of emergency” kind of situation.\n\nAbout a month ago we changed that completely. We had been struggling with code review due to the\nincreased pace of PRs being opened, and so we decided to try something crazy - just not doing it.\nNow the engineer working on a ticket works with Claude, which then opens the PR, and then the\nhuman working on the ticket reviews Claude’s work. Once CI is green & the Greptile review is\nclean, if the human working on the ticket feels confident that the solution is solid, they merge\nthe PR. That’s it. No waiting on a teammate to find time to context switch into your change, no\npinging people in Slack to please take a look.\n\nAnd it’s been working great! When I actually think about *why* it works, it’s because the thing\nthat code review was protecting against is still being protected against. There’s still a second\nset of eyes on every change - it’s just that the author is Claude and the reviewer is the human\nwho owns the ticket. That human understands the problem better than anyone else on the team,\nbecause they’re the one who’s been working on it. They’re a much better reviewer for that change\nthan a teammate who has to page in all the context from scratch. But also, Claude & Greptile are\njust better at finding the kinds of things that are often found in Code Review, like small bugs or\ninconsistencies. It’s pretty rare (at least on the teams I’ve worked on) for big things like\narchitectural flaws or unintended product impact to be found at this stage.\n\nI’ve [written before](https://devonestes.com/trust-collaboration-and-basketball) about how review gates can be a sign\nof a lack of trust, so maybe I shouldn’t have been so surprised that removing one worked out. But\nmy gut still said “you can’t just merge stuff without somebody else looking at it,” and my gut\nwas wrong. At least so far that’s been true - we’re only one month into the change, but it’s\nfeeling really good so far.\n\n## Splitting the team up across separate streams of work\n\nThis is the one that came up in our retro. Recently we had a few people out on holiday, and at the\nsame time we had a couple of parallel and fairly separate streams of work going on. So we split\nit up, and basically each person owned one stream of work and ran with it.\n\nHistorically I really haven’t liked doing this. When everybody on a team is working on a different\nthing, you get knowledge silos. Only one person knows how the thing they built works, and if they\nleave or get sick or go on holiday, the team is stuck. Even worse, I think it erodes the feeling\nof actually being a *team*. You’re not working together to solve the same problem anymore, you’re\njust a group of people solving different problems at the same time who happen to share a standup.\nI’ve pushed back on this kind of setup on basically every team I’ve led.\n\nBut in the retro, we talked about it, and we’re just not seeing any of the consequences I was\nworried about - at least not in terms of knowledge silos. And the reason is that it’s become so\neasy to get up to speed on someone else’s work. If I need to jump into something a colleague has\nbeen working on, I can say to Claude “hey, bring me up to speed on this thing they’ve been\nbuilding - how does it work, where is it at, and what still needs to be done?” A few minutes later\nI have what I need to start contributing. I don’t need anybody else to onboard me, and I don’t\nneed to spend a day reading through code to figure out what’s going on.\n\nThe thing that’s really changed here is that **the cost of context switching has dropped\ndramatically, because we’re operating a level higher than we used to.** I don’t really need to\ncontext switch into the specific code and how it works (or at least not that much to get started).\nWhat I *do* need to context switch into is the problem. As long as I have a conceptual\nunderstanding of the problem that we’re trying to solve, and roughly the shape of the solution\nwe’re going for, I can jump in and be useful.\n\nWill there be some long-term consequences of working this way that we haven’t seen yet? Maybe! I’m\nhonestly not sure. But “maybe there’s a problem we haven’t seen yet” is a very different argument\nthan the one I’d have made a year ago, which was “I’m pretty sure this is a bad idea and we’ll\nregret it.”\n\n## Don’t go deep\n\nThis one is less about how my team works and more about the advice I give to the people I manage.\n\nFor a long time, my standard advice for engineers on their technical and professional development\nwas the classic “T-shaped” thing. First you build up a solid base of general engineering\npractices, and then you pick one or two areas and go really deep on them. Become the performance\nperson, or the accessibility person, or the distributed systems person. Or pick a widely used\nframework and become the expert in it - become a regular contributor to Rails or Phoenix and know\nall the ins and outs of how it works. That kind of deep expertise used to be one of the most\nreliable ways to make yourself really valuable.\n\nNow I’m telling people pretty much the opposite. Deep expertise in a specific technology is a lot\nless valuable when you have a collaborator that has read all of the source code for that framework\nand can answer any question about it in a few seconds. This is another case (like what I mentioned\nabove) where *knowledge* is less valuable, but where *judgement* is still important.\n\nWhat I’m recommending instead is to still build a *very* strong foundation in engineering\nfundamentals, because that’s where I think we as humans offer the most value right now. That’s\nthings like how to architect code, how to design good abstractions, and how to tell when an\nabstraction isn’t really fitting anymore. It’s being able to look at something and say “this is\nstarting to get a little weak, and we should break it up,” and then come up with what the right\nabstraction should actually be. It’s noticing that “it seems like we’re missing something here\nthat needs a name,” and being able to find that concept and name it. That’s the stuff that keeps\nthe high-level architecture, the domain modeling and the data modeling at a high level of quality,\nand that’s where a good engineer really earns their keep these days.\n\nBut I’m also telling them that being great at the tech is now only one small part of the job.\nBeing great at the tech is no longer enough. You need to learn more about design. You need to\nlearn about product development and how to be a product manager, at least a little bit. You need\nto get great at talking to users, doing research and really knowing the business.\n\nI’ve always encouraged that on the teams I’ve led. I’ve believed for a long time that product\nengineering was the best way to do this job. But I used to think of it as the thing that made\nsomeone *great*, and now I think it’s just table stakes. People who just write code, or who are\npurely technical, are already much less valuable than they used to be, and I’m not sure how many\nof those folks will be left in the profession five years from now.\n\n## A few more I’m side-eyeing\n\nOnce I started looking for these, I started seeing them everywhere. These are a few others where I\nhaven’t fully changed my mind yet, but where I’m a lot less sure of my gut than I used to be:\n\n**Rewriting from scratch.** “Never do the big rewrite” is about as close to a universal law as we\nhave in this industry. But a lot of the reason rewrites were so dangerous is that they took\nforever, and the old system kept changing underneath you while you were working on the new one.\nIf a rewrite takes days or weeks instead of years, a lot of that risk goes away.\n\n**Building instead of buying.** I’ve talked a lot of teams out of building their own internal\ntools when there’s a SaaS product that does 80% of what they need. But when building the thing\nthat does exactly 100% of what you need takes an afternoon, that math looks pretty different.\n\n**Building it three different ways.** Writing three different versions of the same feature and\nthrowing two of them away used to be an obviously silly waste of time. Now it’s often the fastest\nway to figure out which approach is actually right, rather than arguing about it in a design doc.\nWe can skip the “rough mockup” stage of product development and just A-B test with actual users in\nproduction if we want, which is a much higher-quality test and leads to things being shipped\nfaster.\n\n**Introducing a language or tool nobody on the team knows.** “We don’t have anyone who knows Rust,\nso we shouldn’t use Rust” used to be a pretty much unassailable argument. I’m not so sure it is\nanymore. Certainly if there are things that *require* a certain language, like some of the\nsoftware we use at Beat81 for interfacing with some parts of our system. We don’t have C#\nknowledge on the team, but it’s also the only driver available for a really good ANT+/BLE receiver\nwe wanted to use.\n\n## What I actually got wrong\n\nWhen I look at these together, I think the pattern is pretty clear. Each of these things was a bad\nidea because of some cost. I *always* think about things in terms of cost vs. benefit. Code review\nby a teammate was worth it because the alternative was nobody else looking at the code at all.\nKnowledge silos were bad because getting up to speed on someone else’s work was slow and\nexpensive. Deep expertise was valuable because that knowledge was scarce and hard to get.\n\nAI has changed a lot of those costs, and it’s changed them really quickly. The rules that were\nbuilt on top of those costs don’t automatically update when the costs change, though, and neither\ndoes my intuition. My intuition was trained over 15 years in a world where all of those costs were\npretty stable, and so it keeps telling me things that *were* true, with the same confidence it\nalways has.\n\nThat’s what really got me in the retro this week. It’s not that I was wrong about one thing (I’m\nwrong *all* the time). It’s that the skill I’ve been using to decide whether things are a good\nidea or not (which has been a big part of my success over my career) is now giving me bad answers\na lot more often than it used to.\n\nSo I’m trying to change how I use it. When my gut tells me something’s a bad idea, I’m trying to\nask the follow-up question: **what’s the cost that made this a bad idea, and is that cost still\nthere?** Sometimes it is, and the gut feeling is still right. But more and more often, the value\nproposition may have changed. I’m certainly erring on the side of at least trying more experiments\nfor things I might have shot down in the past.\n\nThat’s a weird thing to admit after 15 years of being paid, at least partly, for having good\ninstincts. But I think the leaders who are going to do well over the next few years are the ones\nwho can hold their experience a little more loosely, and who are willing to let their teams prove\nthem wrong. This is a time of *massive* change for *everybody*, and so we’ve all got to adapt. Now\nthe thing that I think matters isn’t who has the most experience & knowledge (although that still\ncarries some weight of course), but who can *adapt and learn* the fastest to acquire new\nexperience & knowledge.\n","body_html":"<h1 id=\"bad-ideas-that-aren-t-bad-anymore\">Bad ideas that aren&#39;t bad anymore</h1>\n<p>6 Nov 2026\nDevon C. Estes on\n<a href=\"https://devonestes.com/tag/AI\" rel=\"nofollow ugc noopener\">AI</a>\n<a href=\"https://devonestes.com/tag/Engineering\" rel=\"nofollow ugc noopener\">Engineering</a>\n<a href=\"https://devonestes.com/tag/Leadership\" rel=\"nofollow ugc noopener\">Leadership</a>\n<a href=\"https://devonestes.com/tag/Management\" rel=\"nofollow ugc noopener\">Management</a></p>\n<p>I’ve been working in software for about 15 years now, and over that time I’ve made a lot of\nmistakes and learned from a lot of other people’s mistakes. This experience is a deep well that I\ncan draw from when discussing possible solutions for both technical and non-technical problems.\nThis is how I know what sorts of solutions sound good in theory but run into problems in practice,\nor what fringe idea is actually a perfect fit for the problem we’re trying to solve here. This\nknowledge &amp; experience is a big part of what has made me effective as a leader.</p>\n<p>Lately, though, a lot of the things my gut tells me are bad ideas are turning out to work really\nwell. In our team’s retro this week that hit me pretty hard, and it was a real learning moment for\nme. It made me realize that a big chunk of the intuition I’ve been relying on might not be worth\nas much as I thought anymore, and that I need to question that experience more frequently.</p>\n<p>So I wanted to write down a few of the “bad ideas” that we’re doing right now that are actually\nworking really well, and then to try and figure out what that means for people like me.</p>\n<h2 id=\"nobody-reviews-anybody-else-s-prs\">Nobody reviews anybody else’s PRs</h2>\n<p>For pretty much my whole career, code review has worked the same way: one person writes the code\nand opens the PR, and then somebody else on the team reviews it before it gets merged. The second\nset of eyes catches bugs, spreads knowledge around the team, and keeps any one person from\nquietly drifting the codebase off in their own direction. Merging your own PR without review was\none of those things that was a “break glass in case of emergency” kind of situation.</p>\n<p>About a month ago we changed that completely. We had been struggling with code review due to the\nincreased pace of PRs being opened, and so we decided to try something crazy - just not doing it.\nNow the engineer working on a ticket works with Claude, which then opens the PR, and then the\nhuman working on the ticket reviews Claude’s work. Once CI is green &amp; the Greptile review is\nclean, if the human working on the ticket feels confident that the solution is solid, they merge\nthe PR. That’s it. No waiting on a teammate to find time to context switch into your change, no\npinging people in Slack to please take a look.</p>\n<p>And it’s been working great! When I actually think about <em>why</em> it works, it’s because the thing\nthat code review was protecting against is still being protected against. There’s still a second\nset of eyes on every change - it’s just that the author is Claude and the reviewer is the human\nwho owns the ticket. That human understands the problem better than anyone else on the team,\nbecause they’re the one who’s been working on it. They’re a much better reviewer for that change\nthan a teammate who has to page in all the context from scratch. But also, Claude &amp; Greptile are\njust better at finding the kinds of things that are often found in Code Review, like small bugs or\ninconsistencies. It’s pretty rare (at least on the teams I’ve worked on) for big things like\narchitectural flaws or unintended product impact to be found at this stage.</p>\n<p>I’ve <a href=\"https://devonestes.com/trust-collaboration-and-basketball\" rel=\"nofollow ugc noopener\">written before</a> about how review gates can be a sign\nof a lack of trust, so maybe I shouldn’t have been so surprised that removing one worked out. But\nmy gut still said “you can’t just merge stuff without somebody else looking at it,” and my gut\nwas wrong. At least so far that’s been true - we’re only one month into the change, but it’s\nfeeling really good so far.</p>\n<h2 id=\"splitting-the-team-up-across-separate-streams-of-work\">Splitting the team up across separate streams of work</h2>\n<p>This is the one that came up in our retro. Recently we had a few people out on holiday, and at the\nsame time we had a couple of parallel and fairly separate streams of work going on. So we split\nit up, and basically each person owned one stream of work and ran with it.</p>\n<p>Historically I really haven’t liked doing this. When everybody on a team is working on a different\nthing, you get knowledge silos. Only one person knows how the thing they built works, and if they\nleave or get sick or go on holiday, the team is stuck. Even worse, I think it erodes the feeling\nof actually being a <em>team</em>. You’re not working together to solve the same problem anymore, you’re\njust a group of people solving different problems at the same time who happen to share a standup.\nI’ve pushed back on this kind of setup on basically every team I’ve led.</p>\n<p>But in the retro, we talked about it, and we’re just not seeing any of the consequences I was\nworried about - at least not in terms of knowledge silos. And the reason is that it’s become so\neasy to get up to speed on someone else’s work. If I need to jump into something a colleague has\nbeen working on, I can say to Claude “hey, bring me up to speed on this thing they’ve been\nbuilding - how does it work, where is it at, and what still needs to be done?” A few minutes later\nI have what I need to start contributing. I don’t need anybody else to onboard me, and I don’t\nneed to spend a day reading through code to figure out what’s going on.</p>\n<p>The thing that’s really changed here is that <strong>the cost of context switching has dropped\ndramatically, because we’re operating a level higher than we used to.</strong> I don’t really need to\ncontext switch into the specific code and how it works (or at least not that much to get started).\nWhat I <em>do</em> need to context switch into is the problem. As long as I have a conceptual\nunderstanding of the problem that we’re trying to solve, and roughly the shape of the solution\nwe’re going for, I can jump in and be useful.</p>\n<p>Will there be some long-term consequences of working this way that we haven’t seen yet? Maybe! I’m\nhonestly not sure. But “maybe there’s a problem we haven’t seen yet” is a very different argument\nthan the one I’d have made a year ago, which was “I’m pretty sure this is a bad idea and we’ll\nregret it.”</p>\n<h2 id=\"don-t-go-deep\">Don’t go deep</h2>\n<p>This one is less about how my team works and more about the advice I give to the people I manage.</p>\n<p>For a long time, my standard advice for engineers on their technical and professional development\nwas the classic “T-shaped” thing. First you build up a solid base of general engineering\npractices, and then you pick one or two areas and go really deep on them. Become the performance\nperson, or the accessibility person, or the distributed systems person. Or pick a widely used\nframework and become the expert in it - become a regular contributor to Rails or Phoenix and know\nall the ins and outs of how it works. That kind of deep expertise used to be one of the most\nreliable ways to make yourself really valuable.</p>\n<p>Now I’m telling people pretty much the opposite. Deep expertise in a specific technology is a lot\nless valuable when you have a collaborator that has read all of the source code for that framework\nand can answer any question about it in a few seconds. This is another case (like what I mentioned\nabove) where <em>knowledge</em> is less valuable, but where <em>judgement</em> is still important.</p>\n<p>What I’m recommending instead is to still build a <em>very</em> strong foundation in engineering\nfundamentals, because that’s where I think we as humans offer the most value right now. That’s\nthings like how to architect code, how to design good abstractions, and how to tell when an\nabstraction isn’t really fitting anymore. It’s being able to look at something and say “this is\nstarting to get a little weak, and we should break it up,” and then come up with what the right\nabstraction should actually be. It’s noticing that “it seems like we’re missing something here\nthat needs a name,” and being able to find that concept and name it. That’s the stuff that keeps\nthe high-level architecture, the domain modeling and the data modeling at a high level of quality,\nand that’s where a good engineer really earns their keep these days.</p>\n<p>But I’m also telling them that being great at the tech is now only one small part of the job.\nBeing great at the tech is no longer enough. You need to learn more about design. You need to\nlearn about product development and how to be a product manager, at least a little bit. You need\nto get great at talking to users, doing research and really knowing the business.</p>\n<p>I’ve always encouraged that on the teams I’ve led. I’ve believed for a long time that product\nengineering was the best way to do this job. But I used to think of it as the thing that made\nsomeone <em>great</em>, and now I think it’s just table stakes. People who just write code, or who are\npurely technical, are already much less valuable than they used to be, and I’m not sure how many\nof those folks will be left in the profession five years from now.</p>\n<h2 id=\"a-few-more-i-m-side-eyeing\">A few more I’m side-eyeing</h2>\n<p>Once I started looking for these, I started seeing them everywhere. These are a few others where I\nhaven’t fully changed my mind yet, but where I’m a lot less sure of my gut than I used to be:</p>\n<p><strong>Rewriting from scratch.</strong> “Never do the big rewrite” is about as close to a universal law as we\nhave in this industry. But a lot of the reason rewrites were so dangerous is that they took\nforever, and the old system kept changing underneath you while you were working on the new one.\nIf a rewrite takes days or weeks instead of years, a lot of that risk goes away.</p>\n<p><strong>Building instead of buying.</strong> I’ve talked a lot of teams out of building their own internal\ntools when there’s a SaaS product that does 80% of what they need. But when building the thing\nthat does exactly 100% of what you need takes an afternoon, that math looks pretty different.</p>\n<p><strong>Building it three different ways.</strong> Writing three different versions of the same feature and\nthrowing two of them away used to be an obviously silly waste of time. Now it’s often the fastest\nway to figure out which approach is actually right, rather than arguing about it in a design doc.\nWe can skip the “rough mockup” stage of product development and just A-B test with actual users in\nproduction if we want, which is a much higher-quality test and leads to things being shipped\nfaster.</p>\n<p><strong>Introducing a language or tool nobody on the team knows.</strong> “We don’t have anyone who knows Rust,\nso we shouldn’t use Rust” used to be a pretty much unassailable argument. I’m not so sure it is\nanymore. Certainly if there are things that <em>require</em> a certain language, like some of the\nsoftware we use at Beat81 for interfacing with some parts of our system. We don’t have C#\nknowledge on the team, but it’s also the only driver available for a really good ANT+/BLE receiver\nwe wanted to use.</p>\n<h2 id=\"what-i-actually-got-wrong\">What I actually got wrong</h2>\n<p>When I look at these together, I think the pattern is pretty clear. Each of these things was a bad\nidea because of some cost. I <em>always</em> think about things in terms of cost vs. benefit. Code review\nby a teammate was worth it because the alternative was nobody else looking at the code at all.\nKnowledge silos were bad because getting up to speed on someone else’s work was slow and\nexpensive. Deep expertise was valuable because that knowledge was scarce and hard to get.</p>\n<p>AI has changed a lot of those costs, and it’s changed them really quickly. The rules that were\nbuilt on top of those costs don’t automatically update when the costs change, though, and neither\ndoes my intuition. My intuition was trained over 15 years in a world where all of those costs were\npretty stable, and so it keeps telling me things that <em>were</em> true, with the same confidence it\nalways has.</p>\n<p>That’s what really got me in the retro this week. It’s not that I was wrong about one thing (I’m\nwrong <em>all</em> the time). It’s that the skill I’ve been using to decide whether things are a good\nidea or not (which has been a big part of my success over my career) is now giving me bad answers\na lot more often than it used to.</p>\n<p>So I’m trying to change how I use it. When my gut tells me something’s a bad idea, I’m trying to\nask the follow-up question: <strong>what’s the cost that made this a bad idea, and is that cost still\nthere?</strong> Sometimes it is, and the gut feeling is still right. But more and more often, the value\nproposition may have changed. I’m certainly erring on the side of at least trying more experiments\nfor things I might have shot down in the past.</p>\n<p>That’s a weird thing to admit after 15 years of being paid, at least partly, for having good\ninstincts. But I think the leaders who are going to do well over the next few years are the ones\nwho can hold their experience a little more loosely, and who are willing to let their teams prove\nthem wrong. This is a time of <em>massive</em> change for <em>everybody</em>, and so we’ve all got to adapt. Now\nthe thing that I think matters isn’t who has the most experience &amp; knowledge (although that still\ncarries some weight of course), but who can <em>adapt and learn</em> the fastest to acquire new\nexperience &amp; knowledge.</p>","headings":[{"level":1,"text":"Bad ideas that aren't bad anymore","id":"bad-ideas-that-aren-t-bad-anymore"},{"level":2,"text":"Nobody reviews anybody else’s PRs","id":"nobody-reviews-anybody-else-s-prs"},{"level":2,"text":"Splitting the team up across separate streams of work","id":"splitting-the-team-up-across-separate-streams-of-work"},{"level":2,"text":"Don’t go deep","id":"don-t-go-deep"},{"level":2,"text":"A few more I’m side-eyeing","id":"a-few-more-i-m-side-eyeing"},{"level":2,"text":"What I actually got wrong","id":"what-i-actually-got-wrong"}]}}