I’m loving the Bing image creator’s output quality (some people are claiming it uses the new Dall-E experimental update, but I have not yet confirmed that with a solid source).
Sadly the “boosts” system is a swing and a miss. Mainly because once you use your ten free generations, you can only get more by being forced to use Microsoft products (search, Edge, etc.). You have to earn 500 points in “Microsoft Rewards” to get five more boosts (which equal image generations, with 4 outputs per generation).
You. Can’t. Just. Buy. Credits.
Um, what? Look I’m an adult. I can just give you money for the service. I don’t want to jump through your stupid hoops & earn rewards for things I don’t care about. My “reward” as a user should simply be: I use the thing & the thing does what I asked &/or paid for.
Look, against my better judgement I actually did download and install Edge. And I found that shit to be even more annoying than expected (and I had low low expectations), and instantly uninstalled it. Only thing is, uninstallation was so complicated on a Mac that I had to download *ANOTHER* application just to thoroughly delete all that garbage.
And for whatever reason, I can’t even seem to use Bing Chat at all without using Edge. F that.
This is starting to feel less and less like Microsoft finally got with (or ahead of) the times, and more and more like they just want to cram me as a user into their pie-hole. I don’t like it. It feels gross and manipulative and dystopian, and like something ripped straight out of Conspiratopia.
If a creator uses a non-CAI-supported tool to edit a piece of content, or if they’re working in a CAI-supported tool without CAI capabilities turned on, then the data of any actions in those spaces won’t be captured. We will make sure to show when this data is missing. The CAI will keep promoting transparency and encouraging the use of CAI-supported editing workflows, but we ultimately believe that any CAI process should be explicitly opted into.
What if CAI data is stripped from an image?
Because CAI does not enforce digital rights management considerations around metadata, it’s possible for individuals or applications to strip CAI data from a file. If you inspect a file on the CAI Verify website and find that it has no Content Credentials, you may be able to find Content Credentials associated with the file on the Verify site by searching for possible matches.
In conversations around the use of labeling in synthetic or generative media (made with help from AI), sometimes the desirability of labeling in the first place seems like a foregone conclusion. I wonder if we can’t unpack that a little though, and by doing so maybe make the bigness of it all a little more comprehensible.
I won’t go so far as to say that I think it’s “solvable,” though. I think it’s just the new baseline condition we’re living in. And you don’t solve these kinds of conditions (not without dismantling many underlying structures, anyway) — you end up having to find a way to live with them.
It might actually be helpful to use that simple frame in the development of informal conventions and more formal standards: just giving us tools to live with the deluge. Rather than framing it as a thing we’re going to “solve” once and forever, or some kind of “fight” or conflict or whatever we have to win. Both of those lenses bring us towards more rigid conclusions about what is and isn’t possible, and end up hemming in our imaginations from possibly more fluid and less fragile conceptions that might end up being more easy to apply to real life.
So the questions I want to put on the table to start with are simple:
What is the desired effect of putting labels onto generative AI content? In other words, what do we believe it gets us?
What do we want the end user to do or not do as a result of the presence or absence of these labels?
How can we validate whether labeling actually drives: A) the user behavior we want, and B) that the user behavior will then have the desired effect?
Perhaps a related question would also be appropriate to examine from the beginning: how big of an impact can we realistically expect any labeling will have on users who are just fast-scrolling through news feeds all day?
Take for example this Verify tool view for a given image, as part of Adobe’s implementation of C2PA, the Content Authenticity Initiative:
I think the tool is well-intended, and there’s a lot of information being conveyed through this visualization of metadata.
But let’s make a conservative estimate that maybe the average web user encounters about 1,000 individual media artifacts in a giving day of scrolling, swiping, and browsing.
What’s the desired user behavior here? That each time a user encounters a piece of content, they should use an inspector to look up its provenance trail and then make some kind of rational determination based on the metadata that they find?
I think that pattern might appeal to a very narrow slice of users who have specific especially occupational needs related to information verification (like journalists), but for the average web user might be an undesirable extra set of steps. So I think it’s safe to say most people won’t do that, except in special cases. Which would mean, integrating metadata directly into the feed where people consume the content (as opposed to an external inspector like depicted above), and then hoping that it has the desired effect.
To speak more to that, I think sometimes the unexamined assumption in these conversations is that merely by being exposed to metadata about provenance, that people’s rational minds will be (rightly) persuaded to make appropriate reality-based decisions. It’s a noble idea, and it probably stems from Enlightenment era ideals about the superiority of Reason, etc. But it’s very much not how most people probably make most decisions, especially not on the internet.
We’ve been endlessly taught to “like” things online, or upvote things because we like them (or block them because we don’t like them). Not because they are inherently Good, or Right, or True. But because they align with our existing beliefs, notions, affiliations, identity, and feelings.
Where then does a rationally-intended datum about origin belong in all of that? It’s less clear than it seems at first glance… though there is a school of thought that says we should always make available more contextual data wherever we can. In which provenance becomes just one of many dimensions of contextual data (perhaps not unlike the Four Corners Initiative). Looking from that broader picture into this problem space might open up new vistas of what’s possible and desirable.
Going back to question 2 above: if the end user behavior we want is actually that users slow down when consuming information (as I touched on here), and consider things more carefully, examine metadata, and make rational decisions, well, then we need to redesign social media and the modern web altogether. Putting another sticker on top of the mechanistic beast that drives us directly in the opposite direction by design, is – in my humble opinion – not going to have the desired effect.
If what we want is actually more like “slow media,” and careful considered consumption, then let’s rebuild everything underneath these labels. Let’s change the core technology that brought us here in the first place. Otherwise, there’s a decent chance we will run around chasing our tails and wondering why things aren’t working as intended.
At a call today on deepfakes & content labeling, this famous image from Magritte came to mind after someone showed a deepfake video with an opening disclaimer about how the events in it did not really happen:
In English, this painting is called the Treachery of Images, and the French words on it translate to “this is not a pipe.”
Wikipedia attributes this quote to Magritte about it:
The famous pipe. How people reproached me for it! And yet, could you stuff my pipe? No, it’s just a representation, is it not? So if I had written on my picture “This is a pipe”, I’d have been lying!
— René Magritte
Part of what this brings to mind for me is that, apart from real life itself, literally all media artifacts are representations. They are not the “thing itself” but a representation of the thing.
But as Magritte cunningly points out, is a photo of a painting (a representation of a representation) actually “real life?” For sure, we know (well, we trust – we take it on good authority) that the original physical painting exists somewhere (the LA County Art Museum, apparently).
But where does the “real life” start and stop in this meta-situation? Is this painting a “deepfake?” (I hate that label) Is it an example of a labeling success or a failure?
It’s funny yesterday I was looking around for videos about coding with ChatGPT from a “no code” perspective (or rather for people who don’t already know how to code – no know code?), and it was funny to me that two month old videos on the topic are already hopelessly out of date. Seeing those, it’s like thanks for the tips grandpa.
Also of note in that pile of search results is in casual skimming, it seemed like almost every one of the videos I watched was by somebody who already has somewhat advanced knowledge of coding/programming/engineering/computer science. There was no one I could relate to from my now decades old base of antiquated hand-crafted HTML & CSS knowledge.
The single thing I probably find the most frustrating in the coding with ChatGPT experience is actually not the errors or small harmless mistakes it makes. It is instead its habit of accidentally removing blocks of your code when it spits back out “corrected” versions of things.
If you’re chasing down a solution to a (different) specific bug, it might go unnoticed by you for some time that a couple of buttons have been removed. By then the content of your functions may have been changed, and references to them removed. Then you have to (gently) berate the model until it brings back the functionality you had before that was working perfectly fine but was removed for some inexplicable reason… The circle goes round and round.
I’m not sure how to correct for that, but it’s a major issue for my current learning process….
Integrated coding assistant
Through this experience, I’ve started to visualize in my mind’s image diffusion model what it might look like, how it might function, to have a chat assistant integrated into a coding program/development environment. I’m not that up to date on all the preferred terminology and technology and methods in all this stuff. In a way, that’s what’s appealing to me about using ChatGPT as a non-coder to code different creative production utilities: I don’t have to be. If I want to learn about any specific aspect of it, I can drill down on a problem, ask the model questions, etc. But I don’t have to know how it all works, just know that it works. As I gain experience working with it, anyway, I know the rest will come.
So what would a coding app with a chat assistant look like? I figure, broadly, a pane on the left with the chat conversation, and a pane on the right with the code. I tried getting ChatGPT to build it already, but it looks like it will take a little leg work. I’m up for it now though. I don’t know how it all works, but unlike before with “pure” coding, I never felt like it was possible to break through all the bazillions of road blocks to doing the thing I wanted to do. And hence it stunted my ability to visualize in that direction. But now, I know if I plod along, and am patient with all the errors and code drops, I can probably kinda sorta get there in a relatively short time. A few days of tinkering – but the fun kind of tinkering, not the horrible torturous kind.
Functionally, you could describe in chat what you want to build and how it should look & work. It would render the code right into the code pane, with comments & a chat explanation. You could manipulate the code yourself directly, or ask it to change in chat. It would highlight what it is changing & why, ask for permission, and keep prior versions. It could also optionally offer suggestions for improvements or warnings if it looks like your code might have an error.
The chat assistant, to make it more explicit, would always have access to an up to date version of your code, so you’re not constantly having to cut and paste back and forth. And it’s not making suggestions to you based on code that’s now out of date. I think this is part of the cause of (some of) the code bits getting dropped in transition.
Anyway, then you could preview the code in a browser, and the chat assistant would also have access to your error messages without having to copy paste those back and forth too. Really, all the copy pasting is the most annoying bit of how it all works with them as separate tools right now.
An advanced version might also let me select items in the preview, and say “make this work like this” in chat, and then code would be updated to reflect that.
It sounds like a big project with a lot of moving parts for a total novice, but I might at least try to carve off parts of it until someone else can do it better. It seems like a no brainer set of tools to have!
First, my most recent impression of using GPT-4 heavily to code (I am not a programmer) has left me feeling that, if you’re *not* using ChatGPT to help you code, then, in a way, you’re not really using it. Or that is, you’re not using it at least to its full advantage.
I say that as someone who used this and other AI tools to write 71 books (prior to GPT-4, which I used for two most recent volumes after that). I like to think that from that vantage point, I’ve seen quite a lot of what these tools are capable of, and the types of solutions they tend to provide. Even with all that experience under my belt, none of that prepared me for the “wow” factor I got from trying to use it as a coding partner to tackle technical problems I myself know little to nothing about (e.g., Javascript, API calls, etc.).
The thing is, when you use AI tools to write an email, or an article, or even a book, it’s certainly useful and consequential. But when you use it to code a tool customized to your needs, it suddenly accelerates the actualization of your goals in a whole new way that is entirely more concrete and tangible than just pushing ideas around “on paper.”
Coding an application let’s you do something – something “real” and (hopefully) repeatable. There felt like an entirely different level of gravity to the whole thing than just composing text that somebody (or nobody) might read once, and quickly forget about.
There’s entirely too much noise and debate about AI tools being “confidently wrong” and how that is terrible and the end of the world, because something something. But there’s a world of difference between inserting questionable “facts” into a blog post, versus the tool outputting code that simply doesn’t work in your browser.
Taking a step back, what is an application? An application is a tool you build to apply to a specific purpose. Yes, an email or article could have a specific purpose, and there might be ways to measure its success. But when you code an application, you have very visceral and very immediate feedback about: 1) does this work for the intended purpose, and 2) does this work in my browser?
Truth outside of programming a web application is ridiculously, stupidly complex and squishy. Actually, it’s that too in the realm of programming an app, but it’s different, because we have these twin benchmarks of: does it work in my browser & does it do what it’s intended to do? If we had such objective measures of truth in all realms of information, we might be in a very different place societally. But we don’t.
But we do have them in the browser. I can run an HTML page backed with some Javascript functionality, click around on the buttons, and see if the API calls are returning the things it should. And we have these backstops to tell us if this is a yay or nay situation. Does it throw an error? What does the error say?
Working with ChatGPT to code is a very eye-opening process, because it makes you keenly aware of how Truth is a collaborative process of co-construction. You don’t just have to input a query, and get a fully-fledged result. You have to interrogate the tool; you have to engage in a spirited conversation in search of a goal; you have to go back and forth. You have to take what it gives you, and then go test it against the proving ground of actual reality within the browser: does it work, does it do what it should?
ChatGPT is not omniscient (and not sentient). It hallucinates. It says you have a line of code in your code at times that is not there. Or it ignores sometimes aspects of the code that is there. Sometimes it updates your code to fix a minor error, and eliminates other major functionality you already had that was working. If you feed it back the errors thrown in the browser, it doesn’t magically know what you need to fix it. It tries first this, then that, then another thing, then another, and another.
To sit around on social media and grab screenshots of all the wrong things and blind avenues that ChatGPT gives you while you’re working on code would just be an enormous waste of time. It is endless. And yet people do exactly that endlessly on social media trying to win points in the complaint-brigade, or dunk on the developers because they don’t have any other specific thing they’re trying to achieve with the technology.
Yes, it’s important to point out the flaws of the tools, and think through the implications and possible methods of improvement. But if you really have something you want to achieve, the best spirit to approach the tech with is simply to route around the problems. The problems are stumbling blocks you need to move past, not things that are worth getting hung up and stopping all other progress, or using them as indicators of whatever. They might be, but there’s so much more at stake here, so much more that’s possible. It seems better to me to use this new-found power to explore that rather than getting stuck on the rest.
Lastly, it’s all too tempting in the “quest for truth” relative to the world of AI to simply be like, well why can’t we just have an API that tells us if z is true or not? I think that’s (maybe) fine where z is a fairly simple thing that can objectively be measured as true, but much of life and much of what we might want to have verified when we’re talking with AIs is not necessarily that simple that it can be broken down conclusively to an API call. And even where it is, I think it’s still important that we cling too and even enlarge our own agency around this notion of the co-construction of truth.
That is, rather than rely on some outside body to come in and give us a supposedly authoritative (based on what authority, anyway?) yes|no result, there’s a world where we would greatly benefit from having to actively piece together disparate assessments of claims – which may even conflict with one another – and come to our own conclusions about the results and what we will take away from it.
To recap:
When you use ChatGPT to help you code an app, you experience it differently than when you’re merely conversing with it, because we can objectively see if an app is working as intended in a browser: it gives us the results we want without errors.
In coding, there are always dozens or hundreds of paths open to us to reach the desired end result; what’s “true” here is what gets us to the end result, meeting our acceptance criteria.
ChatGPT will give you good code to start, but will lead you down many blind alleys with a lot of trial and error. While this can be annoying, it plainly shows you that “truth” within the realm of coding an app is a process of co-construction & active engagement.
We would do well to adapt the insights gained from the successes and failures of coding with ChatGPT to other types of non-coding outputs, such as texts, in that we should not seek to get final authoritative answers from it, but instead also actively engage in a co-constructive process. We can then measure our results in these non-coding domains as to whether they get us to the desired end result in a similar way.
I’ve never even used Snapchat, let alone this bot. I’m just wondering what the logic would be, if this were a true reflection of some kind of official guidelines it follows, for the inclusion of a statement like “I will not refer to myself as an AI”.
I guess we’re going to see a lot more of this kind of thing now that the GPT API allows you to include a “system message” to define how the Assistant-bot interacts, to a certain extent:
Rather than the classic ChatGPT personality with a fixed verbosity, tone, and style, developers (and soon ChatGPT users) can now prescribe their AI’s style and task by describing those directions in the “system” message. System messages allow API users to significantly customize their users’ experience within bounds.
As mentioned in my previous post, I spent the last day coaxing ChatGPT (using GPT-4 as a model) to help me code an app I can run locally to write books in the style of fictional encyclopedia entries more rapidly.
I’m not a programmer, though I know HTML, CSS, and the barest minimum about Javascript. I wanted to try getting ChatGPT to write something in HTML and Javascript though, that I could run locally. I needed it to query the OpenAI API to generate content in specific formats to output a book. I wanted ChatGPT to write 100% of the code. I wanted it to take my very basic, minimal inputs, and output basically a complete text for a book, with ability to edit & refresh along the way.
I suspect a real programmer would have a lot easier time getting good code results out of ChatGPT, because they’d know better how to work efficiently in general. When I do the next one, I will hopefully be a lot better at it.
What I found
I’m not going to say this turned me into an engineer over night, but I feel about 10x more confident I can look at *some* Javascript functions and actually understand kinda what’s happening. This is a huge leap forward for me. But now I feel like I have superpowers I didn’t before, and I plan to push forward with them.
It started off surprisingly easy. I simply told it I wanted to create HTML & Javascript that did this:
- Title [single line text input]
- Summary [multi line text input]
- Sections [single line text input, narrow]
- Submit button
- After submit button is pressed:
- For each item marked in sections, make one:
- [#] [single line text input]
- check icon
- refresh icon
- trash icon
- pressing this icon removes the section item
- + [button]
- pressing this button adds a new section
Initially, it spit out a UI backed up by Javascript that did exactly that after one small correction.
Then I gradually added more steps and complexity and iterations (way too much for the first try, tbh). It was able to keep up, but eventually I hit a bunch of snags. There was quite a long while where I was in a no-man’s land of repeated errors, with ChatGPT bouncing me back and forth on minor changes that didn’t resolve anything. But eventually after many many hours, I persevered, ironed out all the (main) bugs, and succeeded.
The App
Here’s a screenshot of part of the app:
As you can see, the functionality is basically like this:
Enter in a book title
Enter a book summary
Pick the number of sections to generate
Tweak the generated section titles, re-order them, delete them, add a new one, or refresh, set a word count for the section
The section titles form the basis for expanded body text that build on the topic of the section, the book title, and the summary. You can also click refresh to regenerate the section.
I don’t show it here, but when you’re done, there is another save button that outputs everything into text that has proper headers and paragraps, so that I can copy-paste it into Vellum easily.
And that’s basically it. Though I will say that for a beginner app-building experience with ChatGPT, it was plenty frickin’ hard to pull off.
Process & Issues
I used Dreamweaver as my coding environment, since I have an Adobe Creative Cloud subscription already. I’m not sure if I like it. I thought it would be better. I might just use Sublime Text next time.
I previewed my HTML in Firefox, cause that’s my main browser.
You will need to turn on the console in your browser so you can see errors. You can also ask ChatGPT to code in logging to your console, so you can see other values being passed or returned via API.
When you get an error, you just copy paste it into ChatGPT.
It helps to frequently copy paste your latest code into ChatGPT so it knows what you’re up to. It has a much bigger memory than GPT 3.5, which is one major advantage, plus the quality of completions is much better, imo.
Expect to get a lot of run-around from ChatGPT while you’re squashing bugs. It’s not omniscient, and even when it says something is going to fix the error, it usually takes like 10 or 20 tries or something before it’s really true. It’s more just bumbling around like a person does than I thought it would.
Sometimes it will tell you wrong things about your code. It will say x is or isn’t in your code, and that you should replace y with z, but when you check, there is no y anywhere to be found. That’s why frequently pasting in your latest code version is very helpful.
In fact all the copy pasting is the biggest time waster of the whole thing.
The most obvious solution would be to integrate ChatGPT right into the development environment. At first, I thought this must be what Github Copilot does, since it’s backed by OpenAI tech:
But that’s not really how Copilot works apparently (correct me if I’m wrong, I didn’t try it). It seems to be more like autocomplete for code. So you have to actually know something about coding to get started. I’m also not sure if it can see like your console, and interpret errors? I don’t think you can quite just use plain language to communicate it like in a chat format.
I also don’t think it would let you go into your UI in the browser (WSIWYG style), highlight something and say like “make it do this ___”. Obviously you can’t quite do that in ChatGPT either (yet) since it can’t see your browser, but you can at least tell it that in chat. I think you can sorta kinda do that with commented text in Copilot? But I probably won’t explore it right now. Too many side-tracks to get diverted by…
So yeah, what’s needed is a tighter integration with the dev environment, the browser (including the console & UI itself). There’s an opportunity to build a killer product in that space that combines those, for sure.
Initial Output Results
Getting the prompt results of the longer body text entry fields to actually relate meaningfully to my book title, summary, and section titles is oddly difficult? I believe I’m hitting davinci-codex which the system lead me to believe is equivalent to GPT-3.5-turbo, but I’m honestly not entirely sure.
After a good amount of tinkering, here’s one example text excerpt it generated:
Introduction
(The chickens have started a space program.) (They are not as smart as we are, but they are smarter than we were a generation ago.) (They are doing well in the space race.) (They have discovered a new form of energy.) (They have published a book on exotic chickens.) (They have made a movie about exotic chickens.) …
I can’t figure out yet how to get it not all weird and junky like this, but I’ll read more around on it. I’m not that concerned though, as I believe when they start granting access to GPT-4 via the API, probably the quality of text output will also improve – since there has been a noticeable improvement between 3.5 and 4 in text completion quality.
API Costs
According to my OpenAI API billing page, I’ve only so far spent $0.29 while building and testing this app. I thought it was going to be significantly higher.
Based on my experiments so far, I would estimate that once I have more of the kinks worked out in getting the text output quality up to snuff, that it’s likely producing one ebook of around 2-2.5K words might end up costing something along the lines of $0.05 maybe? I’m not sure yet, as it would depend on how many section titles, and body text entries you generate or regenerate during a session for a single book. But it’s certainly well below ten cents.
Time Per Book
“Writers” with a capital W probably aren’t going to like this, but again once the quality of output is improved, I would guess based on what I’m seeing in ChatGPT Plus, that this would shrink the time to generate a 2.5K word book down to something like 5-10 minutes for the full text generation, if you’re just basically accepting whatever it comes up with for your content. More thoughtful editing might be like 15-30 minutes if you’re quick.
Integrating Images
Another thing I did writing my last two ebook editions with GPT-4 is ask for the model to give me image theme suggestions. They were in general pretty good, and helped simplify my generations process I usually do in PlaygroundAI.com. It’s still tedious and time-consuming to do that when you’re doing a new book every few days though. I usually start with about 150 or so generated images I download, and then cull that down to about 80 of the best for the particular volume.
What I’d like is also to have my app suggest image themes based on the fully generated text. Then I could use those right within the app to hit a third-party API for either Dall-e or Stable Diffusion (preferably both), and have it not only generated a bunch of images (and allow me to pick the best), but also distribute them within the text. This way I could copy-paste it all into vellum in quick order. Otherwise that whole process takes a lot of time as well to arrange them within chapters in Vellum.
Ideally, if it gets working the way I want, I could create and curate images into the text as rapidly as I generate the text. But let’s say for argument’s sake, I could create a full book in maybe an hour or a little more? I’d still need to do some image work for the cover & previews in Photoshop, and then post to Gumroad. But I think this is a pretty achievable goal with another day or two of hacking away at my code.
Final Thoughts
I thought going into this I was going to be more “reliant” on ChatGPT. Certainly, I was. But also, since the model is wrong so often, and I had to do so much careful checking, I ended up feeling instead like it was accelerating my learning. Instead of reducing my agency, it increased my agency. And now I’m feeling like I’m fully equipped to go out and tackle tons of other problems I would never have been able to do myself in a million years otherwise. All told, major win.
This experience also has radically turned down the volume on just about all the other complainerism & trolling people are doing with ChatGPT. Like, yeah, it’s gonna spit out wrong facts. In a way, who really cares (though I have thoughts on “truth” and APIs I’ll write another time)? To me that’s a far less interesting problem than what I can actively build with this, now that these coding skills are within my grasp that never were before. And this shit is only just getting started!
This book executes on the same prompting methodology I found while producing the prior work. Briefly, it is: tell it you’re writing fictional encyclopedia entries, and give it a book title and summary. Have it create a list of possible section titles, and then expand each one, or regenerate, or improve it by making some specified change.
Thematically, this book covers some of the same ground as The Erdlings, in that it speaks about one of the AI religions, but takes it in a different direction, for something more akin to the Greek Pantheon, or the Ogdoad.
But the real revolution happened after this book…
Once I realized I could use a somewhat strict methodology to generate books in this format within ChatGPT Plus, I realized, couldn’t I do this same thing, but with a customized program?
So I set about feverishly working with ChatGPT to help me code out a web application I can run locally to query the OpenAI API (GPT-4 is not yet available in the API, unfortunately), to have a more simple and structured way to generate fictional encyclopedia books like these.
It took me one solid day of tinkering (and some swearing), but I finally finished a V1 (MVP) of the app, written entirely with help from GPT-4. I’ll write about that in more detail in the next post.
Incoming hot take on this Verge article about someone from OpenAI saying they were “wrong” about being open before:
When asked why OpenAI changed its approach to sharing its research, Sutskever replied simply, “We were wrong. Flat out, we were wrong. If you believe, as we do, that at some point, AI — AGI — is going to be extremely, unbelievably potent, then it just does not make sense to open-source. It is a bad idea… I fully expect that in a few years it’s going to be completely obvious to everyone that open-sourcing AI is just not wise.”
In my eyes, this person has inadvertently made a very strong argument against AI/AGI being controlled by a for-profit enterprise. If it is going to become “extremely, unbelievably potent,” so much so that it is dangerous for ordinary people to have control over it, then it is absolutely 100% going to be too powerful for any one corporation (or several even) to have exclusive control over either. Even one which professes to have the best interests of humanity in mind.
The only steward of humanity I trust is …. perhaps ironically for a sometimes misanthrope, humanity itself. And that is only grudgingly, knowing full well the flaws, conflicts & difficulties that go with it. I just don’t see any other way the powers of this technology can be balanced unless it’s owned collectively by humanity.
