[JM]: Hey everyone, this episode marks the first time I'm recording my side of the audio while on the road, and boy oh boy does it show.
[JM]: You will definitely notice it and hear the difference, and I hope it's not too annoying.
[JM]: We will learn from this and improve our on-the-road recordings over time.
[JM]: In the interim, thank you for your patience with the audio anomalies in this episode, and we hope you enjoy the show.
[JM]: I saw the other day that David Attenborough turned 100 years old, and I can only imagine what it feels like to be 100 and to look back at your life and see just how much has changed over that time span.
[JM]: I am...
[JM]: roughly half his age, and it already feels like the world is very, very different than when I came into it.
[JM]: And I mention this because there's a cool site I came across called sinceyouarrived.world, and it has a few different volumes, and the
[JM]: original volume that's available at the base domain tells you not what has happened since you arrived into this world, but what has happened since you arrived on that particular page load.
[JM]: So I loaded this page right as we started recording.
[JM]: And since that time, however many seconds it's been, it seems that 738 children were born into the world.
[JM]: And sadly, 357 humans have departed.
[JM]: And it goes on to provide these counters, including how many hands were held somewhere on the planet, how many dollars were spent on war, how many songs were listened to, meals were prepared and shared, the number of questions that were asked of so-called AI instead of people, and how many species have sadly vanished from this planet.
[JM]: And there's a couple others here, but it's an interesting collection of statistics.
[JM]: Ten categories thoughtfully chosen.
[JM]: And it's a cool visualization as these numbers increase so quickly that at least the right-hand portions of them are more or less a blur.
[DJ]: This is a cool site, and I really encourage people to go take a look at it and not just listen to Justin's description of it because I'm not saying he did a bad job, but the design and the layout of the site are so well done and so intentional and careful that it really is a work of art.
[DJ]: And the various sub-sites that you might also be about to mention, Justin, are...
[DJ]: Likewise, I was really impressed by the work that's gone into this.
[DJ]: One of the things on that main page alongside the various metrics it shows you is a link to how did they come up with these numbers.
[DJ]: And that itself is very interesting and artful.
[DJ]: So I really suggest taking a couple minutes out of your day to check this site out.
[DJ]: It's pretty magical.
[JM]: Indeed it is, and I'm glad that you highlighted the design.
[JM]: It is very cool the way you have this light-colored side on the left and this dark-colored side on the right half.
[JM]: The typography, it's a really well-designed site.
[JM]: And as you mentioned, some of the other volumes are also interesting.
[JM]: One of them has descriptions of what world skies look like on a particular day.
[JM]: Volume three, I went to briefly, but then my browser asked me to share my location in order to make it function.
[JM]: And I decided that that was not something that was going to happen this morning.
[JM]: I wish there were an allow once option for these browser dialogues, but I don't believe there is such an option.
[JM]: Because if I could just say, sure, this one time, go for it.
[JM]: But I think it's pretty binary.
[JM]: You either allow always or deny always.
[JM]: And that just seems like a silly choice.
[JM]: So Safari, thumbs down on that particular implementation.
[DJ]: I suppose you could allow it and then right away go into your browser settings and remove that site from the list.
[DJ]: But who wants to do that?
[DJ]: And if what you're saying is true, it does feel silly because like the iPhone, if you go into an iPhone app and it requests your location, it does give you the opportunity to allow it once, I believe, or to allow it whenever the app is running.
[DJ]: So, yeah, why don't they extend that to the web browser, too?
[JM]: Absolutely.
[JM]: So I didn't see volume three.
[JM]: Volume four, the most recent one, presumably, when you visit it, shows you a bunch of information that websites can glean from your browser environment and the Internet connection you are using to access the page.
[JM]: So it'll tell you.
[JM]: roughly where it thinks you are, the kind of browser that you're using, the things that that browser is leaking to the website.
[JM]: If you know anything about the concept of browser fingerprinting, then this shouldn't really come as a surprise to you.
[JM]: But the bottom line is that your browser environment, when combined with your IP address and a
[JM]: a unique identifier that sites can use to track you across the web.
[JM]: And the point of the site is, of course, not to track you across the web, but to show you that other sites can do that and to show you what this particular site was able to collect.
[JM]: Because if it can collect this information, well, so can
[JM]: every other site.
[JM]: And when I visited this at the bottom, it said 32 data points.
[JM]: That's how much information this I was able to get from this MacBook Pro that I'm using to browse this site in Safari.
[JM]: And at the bottom of this page, there's wording that essentially says this page has identified your device with enough details to distinguish it from most others on the
[JM]: So if you aren't familiar with the concept of browser fingerprinting, and even if you are, this is a cool reference for seeing what kinds of stuff gets leaked when you visit sites.
[JM]: All right, moving on to some follow-up.
[JM]: In a previous episode, I talked about switching from MacVim to another text editor based on NeoVim that, unlike MacVim, is cross-platform called NeoVide.
[JM]: And NeoVide is relatively new and is...
[JM]: Slowly but surely adopting some of the more Mac specific features that I have become accustomed to over the many years.
[JM]: And so one of the things that it didn't have that I missed is proxy icons, which are these little icons that show up at the top of many document centered application windows.
[JM]: And you can drag that icon to other parts of macOS to drag and drop.
[JM]: As if you were dragging the document from the finder, you can command-tap on them in order to navigate the hierarchy to see where that file is located and let go, and it'll take you to that particular folder in the hierarchy.
[JM]: So I posted an issue just saying in the Neovide issue tracker how it would be cool to have such a feature.
[JM]: And a mere 48 hours later, Alexander Falkucci posted
[JM]: who I presume is one of the Neovite maintainers, submitted a pull request that implements window proxy icons for Mac OS.
[JM]: And it's not available yet in a shipping version, but I downloaded a nightly, tested it out, and in a very peb-cac moment realized that...
[JM]: The reason I couldn't get it to work is because I didn't actually read the documentation that says you need to add this setting, you know, via proxy icon equals true to the relevant configuration file.
[JM]: So, you know, like most good software, you opt into this feature, particularly when it's new.
[JM]: And as soon as I did that, it works like a charm, works just like every other window proxy icon on macOS.
[JM]: So...
[JM]: Hats off to Alexander.
[JM]: I am floored sometimes at how open source works that 48 hours after I requested this, it was shipped.
[JM]: So bravo and footnote because podcasts don't have footnotes, at least not when you're listening in real time.
[JM]: A pebcac moment is an acronym that means problem exists between keyboard and chair, which means the reason that didn't work is because I was the problem.
[JM]: The human was the problem in this equation.
[DJ]: In this case, you forgot the fundamental rule of vim and therefore neo-vim and therefore neo-vide, which is that there is a setting for everything.
[JM]: There is always a setting for everything.
[JM]: Absolutely.
[DJ]: And in fact, as a Vim enthusiast, I like that they did it this way because arguably the proxy icon is a feature of the Neovide application shell specifically on the Mac.
[DJ]: It's not a feature of NeoVim.
[DJ]: But I like the fact that there's only one way to configure the app.
[DJ]: If you are going to configure things about the Mac OS application shell around NeoVim, you configure that the same way that you configure everything else in NeoVim, which is through your init, like your config files.
[DJ]: I think that's a very clever way to keep the experience cohesive, even when they're providing something that isn't really inherent to, you know, what is fundamentally a terminal-based text editor.
[JM]: Yeah, that's an interesting point because one can always argue for either side of that equation, right?
[JM]: Where, okay, in a Mac environment, if there are Mac-specific features, why not put them into a preference setting in the Mac application like every other Mac application?
[JM]: And I think...
[JM]: I think in this particular case, I agree with you that that's probably not the right move in part because in a day and age where at least I am using multiple Mac computers, it's nice to be able to have settings that easily can be synchronized between those different environments.
[JM]: So in theory, I only have to set this in my configuration file once and then the other Mac will just pick it up.
[JM]: Whereas if this were done in a preference setting in a traditional Mac application sense, it would be much trickier to synchronize that setting across my different Mac machines.
[JM]: So yeah, agreed.
[JM]: It's the right way to do this.
[JM]: All right, moving on.
[JM]: In a previous episode, I talked about how
[JM]: When running local large language models, I prefer to do that via Lama.cpp or LM Studio or a number of other tools, except for the one tool that seems to get the most attention.
[JM]: recognition and mentions across the internet and that tool is called olama and i made my case in that episode as to why i don't care for olama and why i feel like you dear listener should also not care for it
[JM]: And I don't know if I did an adequate job of explaining all the various reasons why perhaps you shouldn't use it.
[JM]: Obviously, I can and have talked about why I don't use it.
[JM]: But thankfully, I don't need to anymore because someone has done a very thorough takedown.
[JM]: And I'm just going to read the opening paragraph of what is a...
[JM]: long and very detailed site replete with so many link receipts it will make you dizzy.
[JM]: "Ollama is the most popular way to run local LLMs.
[JM]: It shouldn't be.
[JM]: It gained that position by being first.
[JM]: The first tool that made llama.cpp accessible to people who didn't want to compile C++ or write their own server configs.
[JM]: That was a real contribution. Briefly.
[JM]: But the project has since spent years systematically obscuring where its actual technology comes from, misleading users about what they're running, and drifting from the local first mission that earned it trust in the first place, all while taking venture capital money.
[JM]: This isn't a both sides piece.
[JM]: I've used Ollama.
[JM]: I've moved on.
[JM]: Here's why you should too."
[JM]: And the author starts out by talking about the very distinct and intentional lack of attribution regarding llama.cpp, which is the whole thing that made Ollama work in the first place.
[JM]: And I think that that should really be a big red flag for anyone watching.
[JM]: Looking at any project, if a tool is almost entirely being powered by another tool and you go out of your way to never mention that other tool, that might not be the kind of maintainer and the kind of leadership that you want to invest your time and energy into supporting by using their product.
[DJ]: Yeah, because what are they up to?
[DJ]: Like, what's the actual value add?
[DJ]: And then what is it going to remain over time?
[DJ]: There's always been reason for skepticism here, right?
[DJ]: I think as you laid out and as the author of this excellent article really lays out, that it's felt like a...
[DJ]: It reminds me almost of how Microsoft's behavior was described many decades ago with the phrase embrace, extend, extinguish, with the idea that you take a thing and wrap your stuff around it and make it like...
[DJ]: easier and friendlier, and yeah, come on into our little house, you know, and then once you've done that you can obliterate the old thing, and now only your thing exists, and that does kind of feel like Ollama's move to some extent, and to some extent they've been successful because it is so popular, like there are so many self-hosted LLM-driven tools I see that...
[DJ]: when you look at how to configure them, it just goes like, oh, use, use Ollama to do this.
[DJ]: And, and I find myself because I think you, you very early on talked to me out of, out of using Ollama for this reason.
[DJ]: I find myself going like, wait, no, how, but how do I do it?
[DJ]: You know, a different way.
[JM]: Yeah.
[JM]: And I think the angle that I was taking as it relates to this particular part about not mentioning llama.cpp anywhere is just this notion of trust.
[JM]: It creates, at least for me, a sense of real distrust of the people that are running the project.
[JM]: And I think that there's probably a moral and ethical argument for, yeah, you should mention the tool that allows your tool to even exist.
[JM]: But it's more than just a ethical concern.
[JM]: It's not just a matter, as the author of this article puts it, a matter of open source etiquette.
[JM]: because the MIT license that Lama.cpp is released under has exactly one major requirement to include the copyright notice, which, as you may have guessed, Lama did not do.
[JM]: And when someone brought it up,
[JM]: It took well over a year for maintainers to acknowledge this problem and to rectify it.
[JM]: If you consider proper resolution, adding a single line to the bottom of the readme that says that llama.cpp project founded by Georgi Gerganov.
[JM]: But this lack of attribution is just one of many problems that this author delves into.
[JM]: The link to this article will be in the show notes.
[JM]: I highly recommend reading it.
[JM]: And you're right, Dan, to point out this Microsoft strategy of...
[JM]: Embrace, extend, extinguish, because it is a similar strategy to the extent that ulama takes the tool, doesn't provide any attribution, gets popular, and then replaces that tool so that they no longer have to provide any attribution.
[JM]: and can claim to have added some kind of significant value because they're no longer basing it on llama.cpp anymore.
[JM]: But the other thing, and this is totally predictable, is this pivot from running local models, which again is the whole reason that Alama exists.
[JM]: The whole point is to run local models, presumably.
[JM]: But because venture capital needs to make a return,
[JM]: Unsurprisingly, they are pivoting to a cloud hosted closed source model that you presumably then pay Ollama for.
[JM]: And the author does a great job of calling this out, saying that this follows a venture capital pattern very predictably.
[JM]: where you launch on open source, you don't provide or at least minimize any attribution, you create lock in with proprietary model registry formats, you then launch closed source components, such as the graphical user interface app around Ollama.
[JM]: And then you add the cloud services
[JM]: which is the monetization vector.
[JM]: And like any good takedown, the author provides a list of tools you should use instead, including of course, llama.cpp and llama-server,
[JM]: as well as a bunch of others.
[JM]: And finally, I'll note that it was really gratifying to come across this article because for a long time with seemingly everyone using Ollama except me, at some point I kind of felt like, is this me?
[JM]: Am I the old man shouting at clouds?
[JM]: Is this just another get off my lawn moment?
[JM]: But to see someone else
[JM]: See a lot of the problems that I saw two years ago or however long it's been since I originally decided this tool wasn't a good fit for me.
[JM]: And then to come up with a list of a whole bunch of other things that I hadn't even considered.
[JM]: Yeah, it was very satisfying.
[JM]: So thank you, Zeta4, for writing this very detailed and well-written article.
[JM]: Exposé, another related article that I came across is called Local AI Needs to be the Norm.
[JM]: And much like the other article that I mentioned, well written.
[JM]: The site design here is really cool.
[JM]: I'm a big fan, including the blinking cursor at the top right next to the title of the article.
[JM]: which is in orange, the only bit of color on this page, or at least one of the few bits of color on the page.
[JM]: And the idea here is if you are designing software and in your configuration or preferences, you have a place to just paste an API key for OpenAI or Anthropic,
[JM]: then you have effectively failed us by creating, as the author puts it, a generation of software that is fragile, invades your privacy, and fundamentally broken, resulting in applications that stop working the moment the server that responds to those API calls crashes or your credit card expires.
[JM]: And essentially makes the argument that we should return to the habit of developing software where our local devices are actually doing the computation.
[JM]: And I mentioned this not that long ago where I have this dictation software that I use and I wanted to use the cleanup feature of that dictation software to use a large language model to fix any problems with the detected language in that dictation.
[JM]: But the API calls were just taking too long.
[JM]: And I can't wait for 10 seconds for the dictation result to come back after it's been all cleaned up because it's just too long.
[JM]: At that point, it's faster for me to just type it.
[JM]: And it's only when I switched to a local model that I realized that the problem wasn't in the computation.
[JM]: Or if it was a combination of the computation and the network latency.
[JM]: I don't know.
[JM]: But the bottom line is 10 seconds was too long.
[JM]: And using a local model solved the problem entirely.
[JM]: But this habit of just plugging everything into some remote LLM API call is indeed an anti-pattern.
[JM]: And ends up being this distributed system that in the end costs you money that you don't necessarily need to spend.
[JM]: You already have adequate resources to run very competent local models.
[JM]: And if these features that software developers are adding, you know, can be done locally, bolting on the stuff that makes these remote calls is just, it's an own goal.
[DJ]: From the business standpoint, I was just having a very similar conversation with a friend of mine the other day.
[DJ]: We were talking about how, you know, in people's rush to embrace large language model powered features, I think maybe people are like losing sight of what is a very questionable business decision, which I put this way.
[DJ]: If you take so-called AI out of it for a moment, if I just told you, okay, for the SAS company that you want to build,
[DJ]: Do you think it's a good idea to build a piece of software where every time any one of your users use it, you have to pay another company money?
[DJ]: Does that sound like a good business model for you?
[DJ]: I think your reaction would probably be no.
[DJ]: But all the companies building software whose features rely on calling other companies' APIs to get access to a large language model...
[DJ]: are pursuing that business model.
[DJ]: And that's not great.
[DJ]: And then it's also not great for all the other reasons that you described that are in this article.
[DJ]: The other thing this article reminded me of is the broader concept of local first software, which I have often seen referenced in an essay by, I think they describe themselves as a lab company.
[DJ]: Inc and switch who are at Inc and switch.com.
[DJ]: And they have this sort of essay manifesto about what they call local first software, which is the idea of, you know, to summarize software that principally stores its data and does its computation on your device, as opposed to all of that stuff being in the cloud.
[DJ]: And if you have multiple devices that synchronize with each other,
[DJ]: The synchronization is like downstream of doing the computation and storing the data on your device.
[DJ]: And this has become a fairly popular concept in certain circles, which I've been happy to see.
[DJ]: In fact, there is a local first software directory at
[DJ]: lo-fi.so that you can explore to find various apps that take this approach.
[DJ]: And not that concept is not limited to using large language models, but the large language model obsession that we have in current software development feels like a subset of it, where if you have software that's powered by a large language model and
[DJ]: It is much better for you.
[DJ]: It's better for your business.
[DJ]: It's better for your users if those models can be on your users' devices.
[DJ]: So I'm really a big proponent of this idea also.
[DJ]: Like, I've invested in...
[DJ]: personal computer hardware that lets me run LLMs locally, and while I still use tools from the big so-called frontier AI providers, as much as possible I try to build tools whose use of large language models can go through local hardware that I control.
[JM]: Yeah, and in theory, there are two ways to do that.
[JM]: So if you are developing software, the argument that's being made here that I think is 100% correct is ship a feature instead of shipping some distributed system.
[JM]: In other words, instead of essentially outsourcing software,
[JM]: some feature to some external API call to Google's Gemini or Anthropix Cloud or OpenAI's ChatGPT.
[JM]: Do one of two things, or preferably do both.
[JM]: Allow the user to choose one, okay, use an OpenAI compatible API so you can connect to a model that's running on your local machine.
[JM]: That's a great place to start.
[JM]: It's relatively easy to implement.
[JM]: And then as a second step, look for APIs that are exposed on the device that your software is running.
[JM]: Like we have these incredibly capable pieces of hardware, which are increasingly shipping with software that provides these APIs to software developers so that you can just say, instead of connecting to some external large language model, whether it's running on your device or not,
[JM]: You can just use these built-in APIs to tap into the generative models that are available right on your own devices, thereby, once again, shipping a direct feature.
[JM]: So to take an example of my dictation software, I can already do the first of these two things.
[JM]: I can already and do connect this to a local model that's running on my Mac.
[JM]: But sometimes I forget to start that server process that's running.
[JM]: And so the dictation software will come back to me and provide an error and say like, hey, the cleanup feature didn't run because I couldn't connect to local host server running the model.
[JM]: Really what I want is for this dictation application to use Apple's intelligence APIs to run the cleanup for me so that I don't have to connect it to some model running as a separate process that I have to remember to start and keep running.
[JM]: That would be the ideal way to solve this.
[JM]: So...
[JM]: I agree with the fundamental premise in this article, and I hope that folks who develop software will take notice and start shipping features instead of distributed API calls.
[DJ]: So I am a big fan of this notion of running local large language models, Justin, but I do want to encourage people not to use those models to write really crappy written work and then put it on the internet because there's too much of this already.
[DJ]: And just like you were relieved to find that stop using Ollama article because you had these you have these strong feelings about this topic, but someone else has done such an excellent job of articulating them.
[DJ]: I feel the same way about AI writing because I came across an article on 404 Media.
[DJ]: the other day called Your AI Use is Breaking My Brain.
[DJ]: And this was such a well-written and comprehensive explanation of something that, again, I feel really strongly.
[DJ]: And I'm sitting here going, I'm not the only one who feels this way, right?
[DJ]: I can't be.
[DJ]: And of course, no, I'm not.
[DJ]: And the writer here does an excellent job of describing like what it is about the writing generated by large language models that rubs many of us the wrong way for a variety of different reasons.
[DJ]: I won't go through all of the arguments in the article.
[DJ]: I think you should read it.
[DJ]: And to that end, we will put a link in the show notes that should allow you to read the article.
[DJ]: But for me, one of the things that frustrates me about this form of composition is
[DJ]: That is becoming ubiquitous.
[DJ]: I see it everywhere at work.
[DJ]: I see it everywhere on the Internet.
[DJ]: It's not just the tells that are in the writing.
[DJ]: Incidentally, one of those tells is what I just did, which is it's not just X, it's Y.
[DJ]: As the writer of this article points out, like you'll notice that sentence construction has become so common.
[DJ]: And unfortunately, there's this weird feedback loop where the more that AI writing, so-called, sounds a certain way, it makes us question each other's writing.
[DJ]: Like, wait, did you use AI to write this just because a person chose a sentence structure that is commonly found in the output of large language models, which, after all, were trained on what people write in the first place?
[DJ]: They just over-index on certain patterns.
[DJ]: The real pattern that I don't like in AI-generated writing is
[DJ]: is it uses a lot of words to say very little and one of the classical indicators of good writing is exactly the opposite, which is saying a lot in only a few words.
[DJ]: Doing that is very, very difficult, which is why most people are not good writers.
[DJ]: Because writing well is very hard.
[DJ]: That's why there are entire courses on it and entire books about it and bodies of work that are about this topic.
[DJ]: It's hard to write well.
[DJ]: It's hard to communicate effectively in writing.
[DJ]: And large language models are bad at it.
[DJ]: They're not good at communicating in writing.
[DJ]: And so the more that people use them to do that, the more bad written communication we have.
[DJ]: And the problem is, I'm afraid that the people using it think that it's good.
[DJ]: In software engineering, for example, you can have a large language model generate a summary of your pull request instead of writing one yourself.
[DJ]: I find these summaries excruciating to try to understand.
[DJ]: Because they use so many words.
[DJ]: They just go on and on and on and on about how the changes to this file leverage synergies to like to redact the improve the blood of the maintainability to the like.
[DJ]: They're just they're full of buzzwords and stuff like that.
[DJ]: When as a reviewer of your work, what I need you to tell me is you change this module to do X because Y.
[DJ]: There was a bug in here and I fixed it by doing this.
[DJ]: That's what I need to hear from you.
[DJ]: Large language models do not help you communicate that effectively.
[DJ]: So the biggest frustration I have about the ubiquitous use of generated text is the degree to which people think they're doing the work, but they're not.
[DJ]: Because the hard work of writing is making sure that you're communicating effectively.
[DJ]: And that generally requires you to write something and then edit it.
[DJ]: And edit it and edit it and edit it.
[DJ]: And instead, most people are just getting an LLM to generate text and then not editing it.
[DJ]: And what I find so obnoxious about that is basically what you're saying when you do that is instead of me doing the hard work of getting you to understand what I'm saying, I'm going to make you do all of that.
[DJ]: And I object.
[DJ]: I object.
[DJ]: So now you've heard my main objection to AI generated writing.
[DJ]: And this article in 404 Media does such a good job of describing the many other objections to the ubiquity of LLM generated writing.
[DJ]: That, again, like there's not that much more I can say about it other than please, please go read it.
[DJ]: And then you too, you too shall understand my pain.
[DJ]: And perhaps we'll also feel like someone else understands your pain.
[DJ]: And really, Justin, isn't that all that we want out of life is to know that someone else understands how we feel?
[JM]: Absolutely.
[JM]: And I think that's the point, right?
[JM]: I think that's the chief objection that some of us have to this notion of just interacting with a bunch of bots is that there is no empathy.
[JM]: There is no, Oh, you feel what I feel and vice versa.
[JM]: You don't get that when you're interacting with software.
[JM]: And that's, I think the crux of the issue in general is,
[JM]: and specifically here when interacting with writing that we see on the internet.
[JM]: And you're right to point out that there is this evergreen now argument that's going to be had where you read something and someone posts a comment that says, oh, this is
[JM]: ai generated and someone else posts actually i wrote that by hand and i didn't use software at all and then there's going to be people that say that this was real when it was actually generated that there's going to be this endless debate as to whether or not something was generated by software or not and we're not really going to know the answer
[JM]: But when you feed a prompt into a LLM and you tell it to generate stuff, it's going to produce this homogenous slop because that's what it does.
[JM]: And sometimes it's useful.
[JM]: Sometimes it's not.
[JM]: But almost entirely by design, it's homogenous.
[JM]: And that's generally why I think we object to it.
[JM]: That's generally why we can tell sometimes that it's not generated by a human prompt.
[JM]: And one of the things that the article mentions is that someone created a browser extension called Sincerely, which is spelled wrong.
[JM]: And I'm not even going to bother telling you how it's spelled wrong because who cares?
[JM]: But the point of this browser extension is that there's three modes to undo your LLM homogenized writing.
[JM]: where you can choose between subtle, human, and CEO.
[JM]: And the idea is it will get rid of em dashes.
[JM]: It'll add typos.
[JM]: It'll add slang.
[JM]: It will put words in all lowercase, just like people often do because they're lazy.
[JM]: And this person wrote this because they got tired of everyone in their inbox sounding like LM-generated text.
[JM]: And the intention apparently was that this was satirical.
[JM]: This was meant to hold a mirror up to people who use these tools as a way of not actually thinking and writing.
[JM]: But apparently it's like a legitimate function.
[JM]: People actually use it to make their LM-generated slurry sound like a human actually wrote it.
[JM]: And there's just something infinitely comical about a tool that adds typos.
[JM]: So that when you read it, you think, oh, okay, this was not a large language model.
[JM]: A human wrote this.
[JM]: I mean, I'm left somewhat speechless when considering that this is the world that we live in now.
[DJ]: It feels like a warm bath to me because any good satire is going to go over the heads of some people and they'll take it seriously.
[DJ]: So this is a great example.
[DJ]: Yeah, the author of this tool is quoted.
[DJ]: This isn't a direct quote, but basically of saying something like, you know, I created this as satire to try to get people to think about what they were doing.
[DJ]: But of course, that's going to be lost on some people.
[DJ]: But yes, like the fundamental nature of I am so unwilling to
[DJ]: Do the work or I so disbelieve that I'm capable of doing the work that I'm going to use a large language model to generate some writing and then I'm going to use a different large language model to make the writing generated by the first large language model.
[DJ]: sound less like writing generated by a large language model.
[DJ]: Y'all got that?
[DJ]: I think people like me and presumably the author of this tool would just like want to virtually grab people by the lapels and say, what if you just wrote it yourself?
[DJ]: Come on.
[DJ]: Like, what's the point of this?
[DJ]: And of course, the point is, for most people, the point is just no, I have to send 100 cold emails to people to try to make sales so that my boss pays me my salary so I can pay my rent, right?
[DJ]: Like, that's the reason most of this content exists.
[DJ]: But I continue to find something enervating about the degree to which people rush to stop doing their own work.
[DJ]: The degree to which people don't care about craft in what they do, which I'm sure has always been true for the vast majority of people for a large number of reasons, many of which are valid, like the aforementioned need to pay your rent.
[DJ]: But as someone who does care about craft in what I do,
[DJ]: Yeah, I find it really obnoxious and a downer when people say out loud, because sometimes they do say the quiet part loud, and they say stuff like, you know, when I point something out, they're like, oh, yeah, I generated that with ChatGPT.
[DJ]: I'm like, oh, okay.
[DJ]: So like this isn't your work anymore.
[DJ]: It doesn't matter.
[DJ]: You're not responsible for it because a robot did it for you.
[DJ]: No, no, my friend.
[DJ]: No, please be responsible and exert your human agency over the things that you produce.
[DJ]: Even if you use a large language model to generate some of them.
[DJ]: That's that's what I want from people.
[DJ]: I know I'm not going to get it, but that's what I want.
[JM]: It is understandable that you would want that.
[JM]: And I think that that's really where the author of the article is going with this, because they summarize their feelings very succinctly in the last paragraph when they say that what's driving them crazy is not the idea.
[JM]: that these tools exist, or that people use them.
[JM]: It is, as the article says, And this feels very similar to what I said before when we were talking about
[JM]: LLM generated pull requests and issues in project repositories that I maintain.
[JM]: The whole reason why I'm there is to interact with other humans.
[JM]: It's not just to build software.
[JM]: It's not just to ship software.
[JM]: It's not to merge pull requests that just land without any interaction with a human.
[JM]: It's the human part.
[JM]: That's why I do it.
[JM]: And I think that's why this person is so frustrated that we live in a world now where you have detection tools that detect whether something is written by an LLM only to have people use the humanizing software to make their LLM-generated output sound more like a human to bypass the detection.
[JM]: And then it just becomes this ongoing cat-and-mouse game, which the...
[JM]: vendors of the LLM generated text detection tools themselves say make it look kind of grim for the future of the internet.
[JM]: And yeah, I'm just glad that there are a few of us that are calling forth the idea that really it's interacting with other humans.
[JM]: That's why we're here.
[JM]: That's what we're here for.
[DJ]: Yes, and what really leapt out at me and what you just read was the phrase, couldn't be bothered.
[DJ]: I think that actually puts the finger exactly on what I dislike so much is when someone goes in one way or another, hey, Justin, I would like your time and attention.
[DJ]: I want you to spend some of your limited time on this earth interacting with, reading, consuming, using, reviewing, et cetera.
[DJ]: This thing that I couldn't be bothered with
[DJ]: To actually put any of my heart and soul into.
[DJ]: I think that's a really gross thing to ask.
[DJ]: And I'm sure without explicitly meaning to, it is what so many people are asking so many other people to do now.
[DJ]: And it sucks.
[DJ]: So stop it.
[DJ]: Cut it out.
[JM]: All right, everyone, that's all for this episode.
[JM]: Thanks for listening.
[JM]: You can find me on the web at justinmayer.com.
[JM]: You can find Dan at danj.ca.
[JM]: Reach out with your thoughts about this episode via the Fediverse at justin.ramble.space.