Category Archives: Developers

Questions about the Binance Attack

Binance, the largest cryptocurrency exchange in the world holding an estimated $160 billion in assets, suffered the largest crypto theft in history in late October. It seems that $6.3 billion dollars in assets were stolen with $2.85 billion of the total being frozen or intercepted during the process. The attack was sophisticated and planned for months at the very least.

The initial theft happened within minutes, but the unauthorized transactions continued for amost four hours before Binance finally revoked the malicious authorizations and stopped the attack. Binance, which serves about 300 million users globally, said that it will cover the losses to make customers whole. And in an effort to prevent future thefts like this, the company said it would also increase investment in AI-based detection tools, endpoint protection measures, developer-environment security, and behavioral anomaly monitoring. The company also rebuilt its previously compromised internal AI tool and strengthened its internal access controls.

When the attack started, Binance noticed the activity and immediately mobilized a large security team of engineers, executives, and external blockchain analytics partners to attempt to rapidly assess and manage the situation. But even as the teams worked to contain the attack, the unauthorized transfers continued. The company was clearly dealing with a significant attack that had already moved well beyond its normal withdrawal infrastructure and couldn’t be stooped immediately.

The attackers have been identified as being from North Korea by the FBI in the United States, and multiple blockchain intelligence firms have specifically said group was TraderTraitor, a North Korean cybercrime operation. Notably, the attackers didn’t actually break cryptography systems or steal any wallet keys. Instead, their method was much more subtle than that. They actually gained access to internal Binance systems via well known social engineering tactics targeting employees in the company. Over time, those actions led to the insertion of malware into Binance systems that both leveraged and circumvented the company’s regular authorization infrastructure to ultimately steal the assets.

Early in the process, two Binance engineers downloaded malware that provided internal access to the attackers. The first compromise came in June when an engineer searched online for a popular AI coding tool and downloaded a tampered version of Homebrew, a legitimate macOS package manager, as part of the installation process. The Binance security team flagged that downloaded software as having an anomaly, replaced the computer, and changed all associated access credentials. However, some serious damage was done. The attackers were able to learn the engineer’s role, and they were able to identify additional colleagues working on Binance’s wallet infrastructure.

And then the second breach took place in September when another engineer, while working on a company laptop, engaged in a series of job interviews with a fake company who’s representative asked the engineer to download some code to do a test as part of the hiring process. That second download proved to be fatal. The code was obviously malicious, and the internal Binance security systems didn’t catch it. The compromised software remained undetected was then able to gain access to an internal AI system and also to a third engineer’s computer. The attackers then used those systems to start stealing the crypto in October, bypassing the company’s normal signing and withdrawal processes.

An interesting technical detail is how the attackers exploited the newly deployed Ethereum EIP-7702 authorization mechanism. This software allows an externally owned account to delegate certain execution rights to a smart contract without exposing its private key. The attackers then used Binance’s compromised signing infrastructure to establish unauthorized delegation permissions over the company’s hot wallet. This essentially gave a smart contract, which was now under their control, the ability to execute transactions that Binance had not previously intended to authorize. The cryptographic security of the underlying private key to the hot wallet was not broken. But the authorization infrastructure that controlled how the wallet could be used was certainly compromised.

Binance also used Multi-Party Computation (MPC) for its hot wallet. MPC is a system that distributes cryptographic keys among multiple participants and allows them to jointly authorize transactions without reconstructing the complete private key. However, this did not prevent the attackers from abusing the legitimate Binance signing process. It also complicated the company’s emergency response because there was no single private key available to immediately revoke the malicious EIP-7702 authorizations. Binance had to develop a specific procedure to revoke the authorizations through additional blockchain transactions, which was a time consuming process compared to the rapid speed of the withdrawals.

Some obvious question come to mind here:

Employee Security: How did the attackers get an engineer to download the specific software that was compromised initially after some random searches on the web? And how could another engineer with privileged access to secure internal systems feel free to download and run untrusted external software on a company laptop during a job interview while on company time?

Infrastructure Security: How did a single compromised laptop provide such an easy pathway into an internal AI system, other laptops, and eventually the wallet infrastructure without being detected as malicious?

Authorization Security: How could compromised internal systems go undetected for so long and enable the automated authorization of transactions involving billions of dollars without effective independent safeguards — including human approvals for large transfers — to stop them?

Incident Response: How could the initial June breach not lead to a more comprehensive investigation of internal employee processes and policies, surrounding infrastructure, access credentials, and an immediate updating of all affected security systems designed to protect customer assets?

Binance: 29 October 2026 Binance Security Incident: Initial Findings and Response Update
The Register: North Korean fake job interview led to $6.3B Binance heist
Bloomberg: How Binance’s $6 Billion Crypto Heist Unfolded
Dana Love: Binance Hack? Binance Didn’t Get Hacked. They Got Suckered By A Ten-Year-Old Play
Reuters: Binance hackers used fake job interview in $6.3 billion attack
Patrick Boyle: North Korea Robbed Binance. Can Anyone Get the Money Back?
WSJ: How North Korean Hackers Pulled Off a $6.3 Billion Crypto Heist
Harry Donnelly: How the Biggest Theft in History Happened
Wikipedia: 2026 Binance hack
BTC Sessions: How Binance Got Hit By The BIGGEST HEIST In Human History
TRM: North Korea Steals USD 6.36 Billion From Binance in the Largest Hack in History

“The problem last night was one company keeping billions of dollars of other people’s money behind a single signing system that attackers could get to through an engineer’s laptop. Handing your keys to an even bigger company with an even bigger single point of failure doesn’t fix that. It just makes the target more attractive to the next nation-state with a team of patient hackers. You can hold bitcoin in your own custody, ideally in a multisig setup where no single device, laptop or engineer can move your coins. There’s no need to freeze anything or scramble to find $6 billion over the weekend, and nobody has to wait 40 hours for permission. Get your coins off of exchanges.
— TFTC: Binance’s $6.3 Billion Single Point of Failure

This is not a comprehensive review, of course. There are many more technical reports that go into great detail being published by the security community. It’s a complicated attack because multiple cryptocurrency assets were involved, and the process to steal each one — and also stop the theft — was slightly different. That helps explain the nearly four hours of time needed for Binance to actually stop the action completely, and also why other involved partners were able to freeze their assets before Binance could. The list of links above provide more news and analysis of the situation.

It’s also interesting that there really isn’t that much anger on the Web about this crime. The story is well covered in the media, but the outrage is noticeably lacking. Perhaps the large balance sheet of Binance and the refunding of assets to customers helps explain the muted response of critics. It may be good business for Binance to cover the losses when legally it doesn’t have to, but on other hand, it’s likely that many customers would potentially leave if the assets weren’t refunded. Thus far, customer confidence seems to be holding. Keep in mind that Binance is massive in the crypto industry. The company managed over $34 trillion in trades last year alone. Nevertheless, this latest attack extends the ongoing trend of hacks in the crypto industry, and there doesn’t seem to be an easily visible solution to the problem.

Grok Bot on the Job

I’ve been playing around with Grok Bot recently. It’s not perfect. But it’s really good. And it’s clearly my main AI at the moment. The on ramp is easy, so that’s why I went there to get into agentic programming. I spend hours every day with Grok, and so far it’s been well worth the time and financial investment. Sure, I have conversations with it to flush out ideas, do research, and get back into programming. Just like I’ve been doing with other AI tools. But I really wanted to rapidly assign bots specific tasks that I know need doing but don’t have the time to even start. My To Do list is way too long for anything manual at this point. And I have no time for the moronic AI doomers out there. So, I figured I’d start with something really simple — cleaning up this little website right here. I mean, what could possibly go wrong with that, right?

I asked Grok to crawl the site and draft a plan based on what I have now and what I want to do for the future. In a few minutes I got my plan. And it seemed reasonable enough to at least begin the process. For step one, I just wanted to fix hundreds of broken links and tags in hundreds of posts and pages. Easy, right? But that easy task would take me weeks of daily clicking around the horrible WordPress admin interface, which would only cause endless waves of anger that I don’t need right now. Plus, I’d learn nothing in the process.

So, I then gave Grok direct access to the site, we iterated on what to fix and why, and I scoped this first piece of the project narrowly. After a few minutes of back and forth, Grok went off and fixed hundreds of broken links — in minutes! After I checked things and found that the changes worked, I gave instructions to fix the tags and then I closed my laptop. Grok then went to work on its own computer and fixed hundreds of tags on hundreds of posts while I was walking to the pool for a swim. That last bit felt nice. For the first time, stuff was getting done while I was offline in real life doing something else. As I walked to the pool, I got a ping on my phone via the Grok app that the task was done. Nice. I checked later on and the fixes were done and worked. Simple for Grok, I realize, but for me it would have been tedious at. best.

I’ll never waste my time fighting with the WordPress admin interface or the never-ending snake of nested style sheets on WordPress again. There’s much more to do to just fix things on the site, but I’ll poke at that slowly over time. Then after everything is working as needed, I’ll start working on a re-design for the new projects that I’m planning.

Next up I’m going to automate my social posts that involve just pushing photos from events. I’ll keep my own commentaries on things for manual posting so I can think through each one individually, but for bulk image posting in the hundreds, that stuff will be automated. It’s nice to know that those things can be posted all day and all night while I’m doing other things.

This is only the beginning.

Think First, AI Second

Here’s a cool new study on learning using AI:

Think First, ChatGPT Later: Guiding Human–AI Collaboration for Learning Gains in Independent Human Creativity (April 2026)

The authors, Sarah Shi Hui Wong and Sophia Xuefei Qiu, ran a simple experiment with 196 university students and published the paper earlier this year in Educational Psychology Review. What struck me about the study was that the results seemed so obvious. I must be missing something. But maybe I came to that same conclusion after using various AI tools and just figured out on my own what they do best and what they don’t do very well at all. For me, I found that if I engaged the AI with something already in mind I was far more productive and the experience was more satisfying, whereas if I just randomly poked around with the AI with an empty mind then we both just ended up running around in circles and I learned nothing.

From the abstract:

“Thinking of one’s own ideas first, then collaborating with ChatGPT to improve them, promotes learning gains in independent human creativity.”

And with that, I knew I was on the right track and read the rest of the paper.

Wong and Qiu are researchers working in cognitive and educational psychology, and their study draws heavily on the memory and learning research that those fields have built up over the past several decades. The tradition also traces back to people like Robert Bjork, whose PhD is in mathematical psychology, and other researchers studying how the human brain encodes and retrieves information. These questions predate generative AI, but now they can be studied in the context of AI to explore new possibilities to use the technology. The findings of the ChatGPT study support my own experience since I’ve been using AI specifically for learning from the beginning. It’s the best teaching tutor I’ve ever had by far. The possibilities for education are endless. I wish I had these tools when I was a kid in school.

Here’s what they did with ChatGPT, but it works with any chat-based AI tool. They split students into three groups. The first group solved a creative task alone. The second group used ChatGPT however they liked. The third group followed what the authors called a “think first, ChatGPT later” method. So that third group of students had to think of their own ideas first and then iterate with the AI to improve those ideas. And then they’d submit a final answer on their own like the other groups.

On the first task, the group that used ChatGPT freely did the best. And if you’ve used AI at all, it should be obvious that the first group came out ahead initially. They seemed more productive. But they outsourced their own thinking entirely. Why does that matter? Well, from a longer term learning perspective, this is where it gets most interesting when you look more carefully.

Next, all three groups did a second and harder creative task with no AI access at all. At that point, the free-use group’s advantage vanished. Their scores dropped back to the level of students who never touched AI. But the guided group using AI was different. They hadn’t looked especially strong on the first task, but on the second task working alone they ended up beating the other groups. The researchers then read the chat transcripts and found a possible reason. Students using ChatGPT freely mostly just asked it for external ideas outright, just like I did when I was aimlessly messing around with AI. The guided group, however, mostly brought their own ideas to the chat conversation and asked ChatGPT to push on them. In other words, they iterated. That difference in human behavior, not the AI itself, predicted who actually learned something that resonated over time.

So why is this important? Use AI to help you learn! Simple. And we now have some data in a controlled study to substantiate that AI is a useful tool for learning beyond just anecdotal experience. Sure, AI can make you more productive really quickly, and I use it for that purpose all the time. But to actually leverage the tool it makes more sense to go in with a plan in mind so you can be both more productive and learn something valuable in the process. Then you can take what you’ve learned to focus your prompts to the AI so that you can move even more deeply into the subject. Again, this process is obvious if you’ve spent any time poking around with AI.

Others have also discovered this phenomenon as well. Tamara Tate published a piece called Think First: Why the First Idea Shouldn’t Come from AI in March 2026 before the ChatGPT study, and she made a similar argument about generative AI and writing.

As I read both pieces I found the concepts familiar because they reminded me of a book on learning I read years ago: Make It Stick: The Science of Successful Learning. Make it Stick is probably the best book on leaning I’ve ever read. Every page is pure gold for people who are motivated to learn on their own. The book is based on the same body of cognitive psychology research as the ChatGPT study, particularly the work of Robert and Elizabeth Bjork on what they called “desirable difficulties.” Wong and Qiu cite that same research to help explain why the AI guided group may have performed weaker initially but excelled later. The key is that the students were doing more work up front. Attempting retrieval on your own (thinking first) before instruction beats instruction alone followed by retrieval (testing) afterwards. That’s not a new idea. It’s just being tested on a chatbot now. We now have a new tool at our fingertips to implement an old principle.

Aside from going into an AI conversation with at least a rough plan up front, it also makes sense to spend some significant time iterating with the AI at length. The ChatGPT study only covered a 12 minute timeframe before answers were submitted. But try going longer. I can talk to the damn thing for hours just going back and forth asking and answering questions, brainstorming ideas, taking quizzes, working thorough tutorials, and anything else I can think of. I tend to have hand-written notes to the side, though, to track things that are important and need more probing. I learned this from an engineering manager I worked for at Sun in Solaris engineering where I observed her managing meetings of engineers. She asked one question after another until they solved the problem. I was surprised how deep she could go to get the engineers to think differently about the issue. She always had another question to ask, which led to additional questions the engineers would ask each each other as well. Those meeting sessions would also often lead to further conversations on the team’s mailing list. It works. And AI has infinite patience for this iteration. I guess Socrates was right.

Here’s the final sentence in the ChatGPT study:

“Generative AI is not to be a substitute for human creativity but, when strategically harnessed, a powerful tool for enhancing it.”

Makes sense to me. Working it every day.

The Value of Contributing: Mentorship

I found this interview on the JetBrains YouTube Channel really interesting:

Zig 2026: No-AI Policy, $670K Foundation, Left GitHub & Why Zig Isn’t 1.0 – Andrew Kelley Explains

Some developers really love to code. They share their code and they mentor others to share their code as well. The entire process is a challenge for them. It’s their passion. It’s their craft. And for these guys they aren’t casually dumping their entire development experience for the latest automated AI system to come along.

Here’s Zig Software Foundation lead Andrew Kelley during the interview:

“I love computers. And I love learning about what people are doing with them. And there’s a sense of mystery and magic that you can get from reading someone’s explanation of a project that they did that took them a very long time. They had to learn lessons, and they had to increase their skill as a programmer and as a user of computers in order to accomplish this goal. And when you read a blog post like this, it’s brilliant. It captures the imagination. It makes you think about what you could do yourself. It teaches you something. It connects you to them emotionally.”

And that’s why Andrew bans the use of AI on his Zig projects.

Instead, he’s seeking that close connection with his contributors. He’s seeking excellence and discovery from the many procedures involved in software development. I picked up on this attitude right away because I’ve interviewed many engineers about the value of contributing. Many of them hold remarkably similar views to Andrew, and they talk at length about the importance of contributing to the community.

Here Andrew explains it beautifully:

“The main point of doing code reviews and having contributions, instead of us just doing all work ourselves, is mentorship. The whole point is that a contributor can become a core team member eventually or a more valuable contributor. This will help the project because we’ll have more people who can contribute to Zig skillfully. And it will help their resume because they’ll be a better systems programmer, and they can then take those skills elsewhere.”

But the contributions Andrew used to get from developers using AI were “garbage and had no value whatsoever,” he says. That’s pretty strong language. But Andrew has very high standards and would prefer to engage developers directly on their contributions during the code writing, review, and integration process. That’s where he builds valuable, long term relationships where contributors become more skilled, the core team benefits, and the product maintains the highest quality possible. AI, he says, only gets in the way of that process.

Education is also a big reason for why Andrew holds this view.

“This policy just makes sense because the Zig project is also an education project. That’s part of our mission statement. We’re providing guidance and education to students. So we’re all trying to learn. We’re all trying to get better at programming. And so people who are sending AI pull requests, those people are not helping this goal. In fact, I think that they’re detracting from this goal. So, for our project, I think that the strict no AI policy is an appropriate policy.”

Many times websites bury their organizational mission statements down at the bottom of the page or tucked inside a nav element. But on the Zig Software Foundation site, it’s printed right at the top as the first item.

For developers using AI, Andrew says, it’s simply not worth investing in them. “They aren’t going to join the core team later, not a chance,” Andrew says. It takes too much time away from the reviewers, and the contributors don’t learn anything in the process and are less likely to stick around. Andrew isn’t just saying this, though. His team has tried taking AI contributions but it hasn’t worked out, and they still have hundreds of contributions that still need reviewing. So he’s speaking from his own experience. He’s actually quite thoughtful about the whole thing, so it’s hard to argue that he’s just making a mistake or that he’s blind to the emergence of AI.

So, what’s the lesson? Learn your craft. Learn it well. Go deep into the details so you can demonstrate your expertise so that it’s unmistakable to more advanced developers. And look at the entire process as a community building exercise. In other words, it’s personal. It’s more than just code. Don’t outsource that opportunity to a machine. And then you can build lasting human relationships with the core team via iterations about your code that you submitted yourself. That’s a powerful signal to send into the noisy world of software development. It’s also a simple technique that can be applied to any field you choose. All craftsmen in all trades know this.

Andrew’s position on AI may fly in the face of the current trend of developers embracing AI tools, so we’ll have to see how he and his project evolve as AI grows to pervade more levels of software development. So far, though, Andrew remains emphatic. And judging from many of his comments throughout the interview and how deeply he gets into system development, I bet he sticks to that view. At the end of the conversation, Andrew says he’s probably unemployable at this point and is best suited to be on his own. He’s clearly an entrepreneur at heart, and his standard is “uncompromising perfection.” Can’t argue with that.

And finally, here’s a shout-out to the JetBrains team for talking to Andrew, who said flatly in the interview that he doesn’t use JetBrains products because he only uses FOSS software. Even with advanced IDEs on the market, Andrew’s development set up remains simple and open: “It’s just a terminal and Vim.” Like I said earlier, he loves to code, And he seems as hard core about that as you can get. But the important bit for JetBrains is that they had him on at all. The interview has nearly 900K views in just three weeks, which is vastly more traffic than other recent videos on the channel. Most software vendors would never do this, no matter what traffic a guest could generate. Most vendor channels exist to simply sell products. But JetBrains with this decision demonstrates that they are also concerned with promoting excellence in software development and in building the overall software community. Good for them.

A Treasure Trove of Java Stories

The Duke’s Corner Java Podcast gets a nice mention in the IntelliJ IDEA Java Annotated Monthly for August 2026. See “The importance of telling our Java stories” from Donald Raab right up top: “We all have stories to tell, but they sometimes only get told when we tell them. Jim Grisanzio shared an archive of 77 Duke’s Corner Podcasts, which is a literal treasure trove of Java stories.”

A Double Standard Around AI?

If you follow technology, it’s obvious now that many software engineers speak openly about letting AI agents write their code. And most developers are praised for that move. On the other hand, writers who use similar AI tools to draft their prose usually get a vastly different response. They actually face harsh and sometimes nasty criticism. Why the difference? Both groups use AI, yet the social judgment for each draws radically different reactions. Does that represent a double standard? The two crafts share some things in common, but they certainly aren’t exactly the same so comparing them may be difficult. But they are close enough so we’ll give it a shot.

How Developers Worked Before AI

Picture how developers built software before AI. Roughly speaking, they started with a problem, broke it into pieces, and thought through a basic architecture before typing any code. They chose data structures, wrote functions, planned testing, and reviewed edge cases with team members. When things broke they found the bugs and fixed them. They reviewed their own work and asked colleagues for reviews as well. Every choice in the finished code passed through people. The process was slower by today’s standards, but that slower pace often encouraged developers to think carefully about what they were building before anything integrated into the final product and shipped to customers.

How AI Changed the Developer’s Process

Compare that older process above with how many developers work with AI today. They still start with a problem and break the work into pieces. But the main change now is that they write detailed prompts into an AI system instead of typing their own code. A good prompt can name the files or modules, state the tech stack, describe the desired behavior, and list any constraints. The more context that can be specified up front in the prompt the better. An AI tool then produces some draft code, sometimes across many files, that touch many parts of the system. Developers review the output, run the tests, fix bugs, update the code, and tighten the result. They iterate with the AI as needed by refining prompts or making direct edits to the code themselves. For routine tasks such as boilerplate, tests, or simple refactors, the AI seems to save time for most developers.

For more complex logic or significant architectural decisions, developers still do the initial planning for the project, and they remain responsible for the final code. However, most recently the job has shifted significantly with developers directing multiple AI systems to do the work. This is generally described as managing agents, and it’s characterized as a sign of technical sophistication. Of course, careful human review of the code remains essential for serious work. But a smaller group of developers say they now rarely open the generated files at all because they believe the AI systems are reliable enough. That more extreme group sometimes draws criticism within engineering teams if developers can’t explain or fully own the resulting code. Nevertheless, this trend toward the edge continues and seems to be increasing. Will it mark the new standard in the years to come? There are good arguments on both sides.

How Writers Used to Work Before AI

Now let’s shift to writers. They went through a similar process change as engineers did but on their own, much longer timeline. For them the old way meant research, outlining, interviewing, drafting, and editing using their own editorial or manual tools. Writers wrestled with ideas for days or even longer before they carefully crafted characters and scenes onto the page. They revised their text, cut what didn’t work, and sharpened what did. This iterative process could go on for quite some time during the drafting process. Aside from formal copy editing that came later, the voice on the page belonged exclusively to the writer because every word was written by hand.

How AI Changed the Writer’s Process

Modern AI systems potentially change all of that. Writers can now hand an AI their rough notes, ask for some background research, and get a full draft back in minutes. That may be an oversimplification, but it’s not that far off. From there writers can edit to whatever degree they want to make sure that more of their own voice survives from the original AI-generated text. Writers can even train the AI beforehand to write as closely to their own rhetorical style as possible to reduce the final editing process. So, the starting point for writers has moved from a blank page to a rough draft or even sometimes a seriously advanced machine-generated draft extremely quickly. That shift is similar to a developer’s starting point moving from a blank file to a block of generated code that works as specified.

Reactions to the Two Fields Split Radically

The two examples above aren’t exhaustive or even totally parallel, of course. Developers are much more used to automated systems that aid in building software, whereas writers have not traditionally had tools capable of generating substantial amounts of finished prose immediately. Nevertheless, here’s where the paths split significantly. Although the work itself is similar to some degree, how the world responds to the work is radically different.

When developers say their AI agents wrote most or all of their code, people in the field and observers online often call it efficient and innovative. Companies hold it up as the future because faster delivery requiring lower headcount translates into competitive advantages in the marketplace. That argument is pervasive right now. And engineers who still code everything by hand often hear that they’re falling behind the times. So the bias toward using AI is the clear standard for software development.

However, if writers say the same thing the reaction totally flips. If writers brag that AI drafted a chapter, even one rewritten by hand many times, readers and critics immediately express outrage. Editors ask writers questions they’d never ask developers. Some publications ban the practice outright. Many schools and teachers do as well. The finished piece gets picked apart for tells, real or imagined, in a way finished code rarely does.

To give just a small example of how fast this issue changed on the tech side and how it still lags on the editorial side, check this out. We were told at my last job just last year that we were absolutely forbidden to use AI for anything at work, and then just a year later, virtually overnight, we were absolutely required to use AI for pretty much everything we did. Rapid changes in strategy like that are normal for tech. The editorial community, however, still grapples with even touching AI for any of their tasks. Attitudes in the two fields couldn’t be more different at this point.

Why the Judgment Differs

Part of this disparity comes from how each field values quality work. Computer code has a cleaner set of qualifications. It runs or it doesn’t. It passes the tests or it doesn’t. Users either get what they need from the software or they don’t. But prose has no such test. Readers respond to the human voice and the sense that a particular writer shaped those particular words. And that feeling seems especially sensitive to most people — even for software developers! It’s odd, actually, because I’ve seen many developers who brag they no longer write their own code simultaneously say they’d never read or trust a technical article — or any article — written by AI! I’ve also seen some developers who strongly promote Open Source software violently balk at the notion of releasing their own articles, artwork, or photography under an Open Source license such as Creative Commons.

So, it’s clear that code and prose (and other types of content) are treated vastly differently. If readers and editors, and even developers, learn that a machine had a hand in the editorial process to produce prose then I guess the literary spell and the trust relationship breaks, even when the finished text shows no obvious signs of having been produced by a computer. I don’t get that, to be honest. But I guess some of this just comes down to personal preference.

There’s another piece to this puzzle, though. Code has always been written primarily for a machine to execute. A developer might read it later, but the first audience was the compiler, which flags bugs and turns source code written by an engineer into machine code or bytecode to be executed by the computer or a virtual machine. Success meant that the computer did what it was told to do. Prose never worked that way. It was generally written by one person for another person. It only started roughly drifting toward a machine audience recently, first for search engine optimization years ago and now for AI systems that write, summarize, and reuse text.

That difference in history helps explain part of the discomfort readers feel when they consume AI content. Writers may not realize this but engineers using AI agents are actually extending a close relationship with machines that already existed. Developers have always used the latest software tools to help in the code writing process. But writers using AI are now altering a world that used to belong almost entirely to readers. And readers can feel that shift even when they can’t always name it clearly. We’ve all had the experience of reading purely AI-generated prose. It just feels different, right? And most people wouldn’t want to sit on a beach someplace on vacation reading the latest novel written by a computer.

The tools themselves are also at different stages. AI coding systems have become reliable enough for real production work on many routine tasks and even some advanced ones. And the ways developers can generate, test, and evaluate generated code are often more sophisticated than the ways writers can generate and evaluate the quality of generated prose.

Internal Cultural Standards in Software

But even inside the software industry there are different cultural standards. Programmers who let agents generate code without closely reading or understanding the code are often described as vibe coders, and plenty of other engineers still push back hard against the practice. For them, their standard sounds a lot like the one writers get held to. For example, if they review what the AI produced, test it, and can explain how it works, that counts as real development no matter how much the AI contributed. If they can’t do any of that, though, it doesn’t count. Writers face nearly the identical test. The difference is where that judgement line is and how easily it’s moved. Inside engineering, plenty of AI use still clears the bar and earns credit for the developer. But in writing, even heavily revising an AI draft, it seems that writers can’t clear the line at all, at least not in the eyes of the people judging the finished product.

That explanation only goes so far, though. It doesn’t fully account for why engineers who fail their own field’s test, the ones who openly say they barely glance at the code, sometimes still receive praise for their candor or for embracing the future. Writers would absolutely face a much different reaction for the same admission. So although the work has moved in the same direction in both fields, the judgment certainly hasn’t.

Where Pride in Craft Can Move

None of this is new to developers. Long before AI, many engineers took real pride in writing their own code, not just in what it did as a final product. They argued over whose solution was best. They refused to publish something messy. An ugly or inefficient implementation was an embarrassment even when it worked. They took great pride in authorship with the same instinct that drives writers to protect their phrases, sentences, characters, and scenes. The difference between the fields was never that developers lacked that instinct for craft. Instead, it’s that the instinct for craft in software development had somewhere else to go once AI arrived. And this is a subtle point that the editorial community doesn’t seem to get yet.

For most developers, though, the code was always ultimately a means to an end. The real deliverable was a working system, and the code was the best available way to produce that system. Pride in the craft and the final outcome pointed at the same target for a long time, so nobody had to choose between them. AI broke that link. Once a working system could exist without hand-written code underneath it, the pride had somewhere else to move. It shifted up a level to the architecture, the judgment behind what got built, and the skill in directing agents to write the code. So, the developer’s identity didn’t simply disappear with AI. It just relocated to a layer AI hasn’t fully reached yet. It remains to be seen how developers will react when AI can cover the entire process, perhaps writing machine code directly without source code or maybe enabling non-coders to produce the exact same output as the engineers with virtually no technical input at all. Some say we’re getting close to that reality right now. Personally, I doubt it. There’s much more to software engineering than just writing well-specified source code or producing a final software product.

Why Writers Have Less Room to Move

For now, though, writers don’t seem to have an equivalent layer to retreat to so that their identity remains intact. And the reason may be structural. Developers hide code behind a working system that the user never sees. That’s by design. Two completely different codebases can produce an identical user experience. The code, no matter how it was written, remains quietly behind a layer of insulation doing the work so the product functions.

But prose has no such layer. A reader doesn’t experience some abstracted effect that the sentences produced somewhere upstream. A reader experiences the sentences themselves directly as a new world gets created in their minds as their eyes scan the text. Change the words and you’ve changed the actual thing being read and the world that’s being created. The sentence is often the final product in a way that code usually isn’t. So there’s no equivalent shift available for most writers. Will that change as readers grow more familiar with AI-generated text? And what happens when AI agents can craft long works directly in a specific writer’s voice without any human or machine detection? At that point, perhaps reading the latest novel on the beach written by a computer won’t be so bad after all. We’ll see.

Markets, social pressure, and personal preference all reinforce these views for now. Software users and companies primarily care whether the system works, how much it costs, and what value it produces. But most readers of prose still treat the human relationship with an author and the sense of a particular mind behind the words as part of what they are buying. Countless readers return to text over and over again simply to experience the pleasure of how specific passages are crafted. And people re-read books many times to learn deeper meanings over time. Authenticity is a timeless cultural preference here. It’s part of the very product itself for a large share of the writing market.

Copyright and the Writer’s Dilemma

There’s another structural difference that writers face and developers largely don’t. That’s copyright. For a writer, publishing text that contains significant AI-generated material creates a genuine legal and commercial question. Under current United States copyright law, purely AI-generated expressions aren’t protected simply because a human prompted the system. Although a larger work can still receive protection when a human author contributes sufficient expressive elements, but the boundary depends on the specific work. For now, humans at publishing institutions are making those judgments through various editorial policies and cultural practices.

Regardless, this distinction is still uncomfortable for many people. A writer who generates a chapter and publishes it essentially unchanged may have little or no copyright claim to the AI-generated expression itself. But a writer who uses AI as a starting point and then substantially rewrites the material may have a stronger claim to the human-authored portions. The machine can make the work easier to produce while also making the boundary around authorship harder to define. This is one reason the reaction to AI-assisted writing may not rest entirely on questions of linguistic purity. There’s a real intellectual property question here.

But developers face copyright and licensing questions as well. Code has to fit inside an intellectual property framework involving employment contracts, proprietary software licenses, or Open Source software licenses. A developer may need to worry about whether AI-generated code resembles existing copyrighted code or incorporates material subject to a particular license. But the question of whether the developer personally authored the expressive work is usually less immediate. For writers, though, the words themselves are the final product, so the copyright question is personal and potentially significant.

Patents and the Developer’s Emerging Concern

Writers aren’t the only ones with legal exposure, though. AI may complicate the situation for developers as well because of patents, which affect developers working on genuinely novel inventions. Although AI-generated code doesn’t automatically create a patent problem, the issue does need consideration. Patent law is concerned with the invention and with who actually conceived it, not necessarily who typed the code. The United States Patent and Trademark Office’s current guidance says the same inventorship standard applies whether or not AI was used. AI can assist a human inventor, but only natural persons can be named as inventors.

That creates an interesting problem. Suppose developers know what they want to build and use AI to implement a technical solution they had already conceived. That’s one thing. But then suppose developers give the AI a problem and the AI comes back with the novel mechanism that actually makes the invention work. Developers may have directed the system, but direction alone doesn’t necessarily establish inventorship. The important question is whether the developers made the required contribution to the claimed invention.

An AI-heavy development process could eventually create a strange reversal. Developers may end up with more efficient code and a better product but also with less certainty about whether their contribution was sufficient to establish inventorship of the underlying technology. Here’s where AI could actually earn its characterization as true artificial intelligence because in that case it would be part of the creation process itself.

There’s another issue too. Developers working on potentially patentable inventions need to be careful about what they put into external AI systems so they don’t inadvertently expose trade secrets. But the problem is broader than trade secret law. Developers have contractual or employment confidentiality obligations even when the information does not qualify as a trade secret, and these things can’t be violated as well. Patent law also depends heavily on novelty and timing, and public disclosure can lead to consequences that vary by jurisdiction.

The safest approach is to keep track of what the human actually conceived, what the AI contributed, and where any confidential invention details were sent during the development process. This can obviously get complicated as the use of AI becomes pervasive and as swarms of agents handle more and more complex computer science tasks autonomously.

So, although not exactly the same, patents can be a useful counterweight to the copyright comparison. Developers may not have the same immediate authorship problem as writers have, but they aren’t completely outside the intellectual property problem either. These legal questions have simply moved to different layers for each field and will need to be ironed out in the courts as issues come up.

Institutional Rules Differ Too

Institutional rules and agreements reinforce the disparity between writers and developers as well. For writers, publishing contracts, academic policies, and editorial standards still treat AI contributions as something that must be disclosed or even banned outright. But software employment contracts and Open Source development practices treat AI assistance as ordinary tooling with far fewer formal restrictions.

There’s yet another wrinkle in the rules game: international regulations. The European Union is beginning to treat transparency around AI-generated content as a regulatory issue. The EU AI Act’s transparency obligations under Article 50 came into effect on August 2, 2026. Among other things, the rules require certain AI-generated or manipulated text published for the purpose of informing the public about matters of public interest to be identified as artificially generated or altered. There are exceptions, though, including situations involving human review or editorial control. So this is not a blanket requirement that every article or book touched by AI carry a label.

That’s interesting when you consider the difference between writers and developers. A person reading an article may have an interest in knowing whether the words were generated by a machine, particularly when the article is intended to inform the public. A person using a piece of software, however, generally has no comparable expectation that they should be told whether an AI agent wrote some or all of the underlying code. The EU rules could, therefore, suggest a broader distinction between AI used to produce code in a software product and AI used to produce prose in a book that another person consumes directly.

The EU is also putting copyright obligations directly on providers of general-purpose AI models. Those frontier providers must have policies for complying with EU copyright law and must publish a sufficiently detailed summary of the content used to train their models. The relevant obligations for general-purpose AI providers began applying in 2025 with the European Commission asserting enforcement powers over those obligations in August 2026. At present, most major model providers are complying or plan to comply.

Even this issue is still developing. Different countries will continue to approach AI, copyright, patents, and disclosure differently. It’s probably too early to tell whether these regulations will create a permanent distinction between writing prose and writing code, or whether that line will blur as AI becomes a normal part of both professions.

What the Split Inside Software May Suggest

Although the software industry has generally and enthusiastically embraced AI, not every developer is making the shift easily. The ones who built their identity on demonstrating individual skill, the tightest solution, or the best line of code still feel a loss that looks remarkably like what writers describe. For them the code was never just a means to an end. It was closer to the point itself, and you can see that feeling come through passionately in many reactions on social media as developers are forced to use these new tools.

People in both fields also worry about the next generation. In software the fear is that junior developers will never build the necessary technical skills to understand, debug, or design complex systems. In writing the fear is the loss of voice, critical judgment, research skills, and the long apprenticeship of writing as a craft. Watching some developers relocate their pride with ease while others struggle to let go of authorship suggests that the split may run through personal temperament more than through evolving professional standards. Writers may be looking at a preview of their own future in that split with some finding a new place to put their pride and others not finding one at all.

Maybe there’s another difference that will become more important over time. Software has always been layered. A developer can move from writing code to designing systems, then to architecture and product decisions, and eventually to deciding what problems are worth solving in the first place. Writing and editorial production has layers too, but the final expression remains the exposed text. An author can move toward research, structure, editing, or directing AI, but eventually the reader still encounters the words themselves. If those words can be produced almost entirely by a machine, the question of what exactly the writer contributes becomes harder or impossible to quantify. Each profession will have to establish a new definition of meaningful human contribution and quality of work.

There’s no obvious answer yet. Things will remain messy for a while. The technology is moving too quickly, the law is now moving along with it, and opinions are not consolidating. The European rules are only beginning to take effect, the copyright questions are still being worked out, and patent authorities will have to apply old concepts such as inventorship to a technology that didn’t exist when those concepts were created. So, it may be that the differences between writers and developers become smaller over time. Or the legal and cultural systems may end up actually reinforcing the differences.

Never Ending Change

For now these are just some questions worth watching. Maybe the honest answer to the original question about the double standard is that there really isn’t one. Despite sharing some common characteristics, the two fields are structurally different enough so AI will simply be implemented differently for both. Who knows how this will turn out. I guess we’ll all just grind our way through it to some conclusion or another.

Interviewing Developers

Since 2017 I have interviewed about 500 developers for articles, audio, video, and live streams at events on a variety of topics including Java, Linux, Oracle Database, MySQL, AI/ML, Developer Tools, Oracle Cloud, and Open Source. 

Libsyn Audio | Podcast Video | Highlights on X | Photos

Most of my interviews these days take place via Zoom from my kitchen, which I find frustrating because I greatly prefer the connection of live interactions at conferences. That’s a bug. I’m working on a fix. But for now, I’m making do. The checklist below captures some insights I’ve gained about the interpersonal dynamics of interviewing software developers. This isn’t about podcast equipment or technical setup. Instead, it focuses on creating a comfortable environment for guests, drawing out compelling stories, and fostering engaging conversations that resonate.

As I continue learning, I revisit these points regularly and update as needed. They’re shaped by my own painful journey in this field without formal mentorship, so I’m always open to feedback to help refine my approach. The whole experience has been pretty personal for me, to be honest, considering that I’ve radically changed careers a few times, I’ve had to start over from scratch repeatedly, and I couldn’t talk fluently until I was well into my 40s. So be it. That’s life.

Anyway, here’s what I’ve learned so far.

Before You Hit Record

Talk to them first.

Don’t just send your guests a calendar invite with a link and hope for the best. Some developers aren’t used to being interviewed, and they may be apprehensive initially. Do a quick call first. Send them an email explaining what you’re doing. Is this video or just audio? How long will it take? What kinds of things will we talk about? Then, when the interview day comes, I always start recording at least 15 minutes after getting on the call just so we can chat about their latest projects before recording, which helps guests get comfortable, sets a collaborative tone, and organizes things in my own head as well. I’m always nervous at the beginning so killing a few minutes up top is always best.

If you are live on site, you can do this simple preparation work right before you turn on the camera if you have a simple interview with an experienced guest. But for more complex things, you may need more time to prepare. For example, at JavaOne 2025, I ran a Duke’s Corner Podcast panel during the Day 3 Community Keynote, and for that I did a lot of preparation. First, I did my own prep to scope out the entire segment. Then I selected three interesting Java developers as panelists. Then I pinged them via email with all the details, and we had some online threads as we agreed to everything. Then we met as a group at the JavaOne speaker dinner on Monday a few days before the keynote to go over issues together and start the process of gelling as a group. Then we participated in rehearsals with the other Day 3 speakers on Wednesday. Then finally we ran live on Thursday. The result? Our session was perfect! But it did take some real preparation. When the stakes are high like this (a live keynote session) it’s best to layer the preparation with your guests so you don’t miss any of the details and everyone knows what to expect.

Do your homework.

If you show up unprepared, you’re wasting everyone’s time. And if your guest is experienced, you also run the risk of embarrassing yourself. But most developers aren’t experienced at interviews, and they aren’t media trained with prepared talking points like you’d get with a CEO or marketing executive. It’s your job to dig into their work a bit and find a few interesting threads. Check their GitHub accounts, read their blogs, look at their conference talks. If they’re involved in a user group, find out what they’ve been up to lately. Check their posts on X or LinkedIn or their project mailing lists to stay current with their latest community discussions and contributions.

This homework isn’t just about having some solid background data to generate interesting questions. It shows respect for their work and their time, it builds a genuine connection when you meet, and it makes the whole conversation flow better. 

Start Strong, End Strong

Jump right in.

Don’t waste time with long, awkward small talk or forced jokes at the start of an interview. Pre-plan the start so you can begin efficiently. This is always the hardest part for me, especially when doing live streams because you only have one take. So, just do your introduction, get a quick response, and get going into the content. You’ll feel better once things get rolling! For example, if your guest organized a hackathon recently that helped streamline bug triaging, start there. That’s perfect. After your introduction and your guest’s response, jump in with something like this: “Hey, I saw your recent hackathon — tell me how that came together.” In other words, be pleasant and professional. But move! I’m not saying you have to make the intro so short to fit into the insane YouTube “shorts” of mere seconds up front. But don’t hang out with meaningless jabber either. 

Plan your exit.

Every conversation has a natural lifespan. You’ll feel it when the energy starts winding down, you’ve run out of questions, or your start repeating yourself. Plan for wrapping up smoothly. I always tell guests upfront that I’ll give them a chance for final thoughts when we get near the end. When you feel that you’ve covered everything you can simply move along to this: “Ok, before we wrap up, is there anything else you want to add? Any plans coming up? Anything you want the community to know before we go?” Now, I wouldn’t ask all of those questions in a row like that. Those are just examples of one or two to use. After their response, it’s perfectly acceptable to say, something like this: “Oh, I love that. That’s great. Ok, we’re done. Let’s get out of here! Have a great trip to JavaZone in Oslo. See you next time.” Or something like that. They’ll respond with a quick bit. And you’re out. Or sometimes you’ll be able to cut right after your goodbye. Just go with the flow but always have the intention of ending things with some precision. If you want to summarize some key takeaways occasionally before saying goodbye, and if it feels natural, that’s fine too. There are many ways to end. Just don’t drag it out. Also, always thank your guests and tell them when the episode will be out. The goal here is to get out before the energy dies because it will be obvious to listeners if you don’t. 

Listen!

Your superpower is your silence.

Listening. This is critical. It sounds obvious, but really very few people have mastered this skill. Actually listen to what your guest is saying in real time. You must listen to your guests while they are talking not only so they feel heard but also so you can facilitate the conversation naturally and things flow well. It’s obvious when one person in an interview is not listening to the other person. You can see it all over YouTube and especially on news programs. Also, just recall conversations you’ve had in real life. You know immediately when you aren’t being heard, right? Now put that experience on audio and video for all to see and hear. It’s ugly. 

I know it’s tempting to think about your next question while your guest is talking. But resist that urge. If you are on site, I know it’s hard to listen when there are sound distractions in the room, and when you’re worrying if someone will crash into the camera (which happened to me many times). And, of course, it’s hard to listen when you can’t remember if you even turned on the camera or if you focused properly and set the white balance correctly. It’s best to have a short checklist on site because things can get confusing, especially when you are working alone, which has always been the case for me. And even have a short checklist for doing Zoom interviews from your kitchen. Checklists work. Remember, surgeons and airline pilots and people in many other professions use checklists daily so there’s no reason we can’t as well. 

Use whatever tool you can to free your mind so you can listen in the moment. When someone tells you about fixing a critical bug or organizing their first meetup, really hear them as they are talking. Respond with some body language so they know you are following their story. Paraphrase what they said: “So your mentorship program actually helped people contribute to OpenJDK for the first time? That’s excellent!” This shows you’re paying attention and often encourages them to elaborate with even more details. Simply providing a brief summary is a great way to keep people talking while you navigate the conversation.

And don’t be afraid to respond with short quips like: “That’s cool!” or “Wow! How’d that work?” when something genuinely interests you. Sudden and authentic reactions help keep the conversation flowing naturally, which is what we all do in normal conversations without microphones and cameras. Just think of the last chat you had with a friend in your favorite coffee shop as a great example of normalcy. Try to keep your guests talking with subtle, familiar cues like this. Or sometimes, if they end before you think they should, be even more obvious. “No, keep going! That’s great. How did that situation end?” You’ll probably have to do this with a semi humorous voice to avoid appearing too aggressive. Most people get it, though.

Bridging and Flowing

Keep it moving.

Comment on what your guest just said before moving to the next topic. It would be great if you could also weave a new issue into your summary of their previous comment to help bridge them to the new issue. If they mention contributing to a project, acknowledge it: “That bug fix sounds like it was pretty complex. How did you approach that with so little information and no time?” You’ve summarized their comment and added a new bit in the hopes of moving them along if the next issue is a logical next step or somehow related. If things are dragging along too much on any given subject, though, you may need to shift topics more assertively because bridging isn’t possible. Just be direct: “That’s great. Really cool experience. Ok, let’s move on to the community. Talk about your work with your local user group. I’ve heard you are running the JUG now.”

If they keep going off on tangents about something unrelated, gently redirect: “That’s interesting. Hold that thought. I want to go back to your contribution process first…” Or even more direct, “Wait, go back. That was interesting.” Use their input to steer the conversation smoothly in the direction you want to go or to keep them moving along their path efficiently. If they casually mention mentoring and then move on to something else without saying much, make a mental note to ask about mentoring next. This keeps things organic and layers issues in some logical way. Now, there are cases when you don’t need to respond to topic shifts. Their answer just ends a good sequence really well, and maybe you can provide some silent space and some body language to move along. Watch skilled interviewers. They do this more than you realize. 

And finally, try to keep the conversation going fluently by directing your guest to comment on specific issues rather than always asking question one, question two, question three. Weave in some open statements like, “You mentioned you’ve contributed to the Linux kernel as well as OpenJDK. I thought that was interesting. Tell me more about that.” In other words, you aren’t even asking a question here. You’re getting people talking by making statements or directly telling them to comment on something. Think about normal conversations with your friends. They’re based on a variety of free-flowing questions, statements, prompts, and body language. No one likes a formal Q&A session. Mix it up so the discussion is as natural as possible. 

Asking Better Questions

Simple is best.

Keep it simple! Ask one question at a time. Or if you ask two make them directly related in a string where one builds on the other to add more clarity. Don’t ask disparate or compound questions! This only causes stress as the guest, the audience, and you try to keep track of your too-cute “three part” question. I see people ask these compound questions all the time: “How did you get started with OpenJDK, and what was your testing process, and also how did that work connect with your user group experience?” Nobody can answer that well, especially if you’re doing a live interview at a busy conference with a microphone right under your guest’s nose and a camera focused on their face. Where would they even start? Your guest won’t appreciate the unnecessary complexity too, trust me on that. I’ve made this mistake many times.

Instead: “How did you get started contributing to OpenJDK?” Stop. Let them answer. Then follow up: “Oh, sounds like a great opportunity. What was your testing process like before you submitted your code?” Stop. Let them answer. Then follow up: “I see, ok, so from that code integration process you met the JUG leader since he was the gatekeeper on the project.” That’s not even a question but those statements summarize the story and encourage the guest to say something like this: “Yes, we had so many conversations getting that fix tested and integrated on a tight deadline that we became friends and she invited me to do a session describing the technical details at the next JUG meeting on contributing to OpenJDK.” 

So, if there are multiple parts to an issue, break things up into multiple questions and statements and just talk them out to their natural conclusion. No compound questions ever! Don’t put that tracking burden on your guests or yourself.

Also, try using some open-ended prompts: “Tell me about that bug fix” rather than “Did you find it challenging?” The statement “tell me about it” opens things up, whereas the “challenging” bit narrows things down. Both are valid but know when to use them. Ultimately, you want your guests to describe situations and stories and entire sequences of events, not simply answering yes/no answers. Always encourage people to tell you about something. In other words, prompt them and then step back and give them some space to explore. Then you can judge how much time they need, and you can adjust and guide them where needed. The goal here is to get them to describe experiences they’ve had via short stories. That’s what makes it easy for them to speak articulately for longer periods of time because as they are speaking they are re-living the the experience. And that’s when their natural personality comes out.

If the issue is complex, you may need to get more specific: “Break down your testing framework as if you’re explaining it to a new engineer on the team. Just give me a few of the more important steps to follow.” Don’t expect them to give you the full task list from the manual to do an integration. But you can expect a top-level overview of a process just as they’d do in a normal conversation. And avoid leading questions like “Isn’t X process better for that issue?” Instead ask “What drew you to that approach?” to get more detailed responses. There’s no need to put them on the spot with your judgements. Plus, you may not like it if they come back and embarrass you with their response! Remember, this is a conversation, not a competition. 

Getting Good Stories

Everyone loves a story.

Before you start recording, ask your guests to think about a few stories they can tell. It’s good to have this conversation before the interview so they have some time to think about blending some stories into the overall themes of the conversation. You need details in responses, of course, but those bits should be expressed through a series of situations or short stories. This is why you don’t need to provide specific questions up front. Just offer your guests broad topics for discussion and let them wrap their content into their own personal stories. Once the story starts, you can listen if it’s flowing well or insert some quips to move things along in whatever direction that’s necessary. 

Funny disasters work great as stories. “Tell me about that time you accidentally took down the bank on day one” or “What’s the worst bug fix you’ve ever integrated on a Friday afternoon?” A few dramatic stories in a conversation can go a long way to making things interesting and less stressful for both parties. These kinds of stories reduce stress and provide the audience with relatable, genuine, and memorable experiences. But be careful with the disasters. Make sure that everything worked out ok because you don’t want to surprise them on a live interview if something really terrible happened.

Also, when people tell real stories, their whole demeanor changes. Watch for this and encourage it with your own body language. They may get more animated, more detailed, more authentic. They light up! Watch how they come alive right in front of you! The technical stuff is important, but the human stories are what make people want to keep listening. 

Push for vivid details.

If possible, ask questions that create scenes and narratives. Weaving in the five human senses (hearing, touch, sight, taste, smell) is a helpful technique. “What was it like in that room when you realized what happened? Who else was there? What did they say?” Probe for how things were felt. Also, directly ask your guests to take you there: “Wait, go back. Take me into that scene. What was it like when you first heard you were nominated and approved to be a Java Champion? You were on the keynote stage in front of everyone. Wow!” Get them to talk about the situation by reliving the memory. They’ll love it. What was on their screen when the system crashed? How did their team react? What did they do when they were organizing the event when the hurricane hit and blew trees into the conference center? Things like this. Thinking in terms of human and natural elements makes stories that have technical details more engaging.

Managing Different Comfort Levels

Being interviewed is a unique experience. 

Recognize that being interviewed is a different skill than presenting a session. I’ve seen some famous developers who regularly present at big conferences in front of thousands of people who actually feel and look noticeably uncomfortable being interviewed. And this makes sense. They don’t have a laptop in front of them. They’ve not rehearsed the discussion. They’ve not been media trained. They don’t have control! Don’t assume they’re skilled at this specific task of recorded or live, free-flowing conversations, especially when you stick the microphone under their nose for the first time. One time I was at a conference streaming some interviews, and the guest wanted to use his laptop and show his slides. He just had no confidence that he could take his content and turn it into a verbal conversation. It happens. And it’s your job to manage this problem.

Make it a habit to put all your guests at ease right up front. Frame it as a fun chat to share their story with the community. Tell them this is a mutual discussion, not a journalism interview. We’re having some fun here! That’s it. Let them know that pauses are fine, stumbles are normal, and you can always edit things out later if something breaks. I often mention that I mess up my own introductions half the time, which helps them relax. And when I wreck their names in the first five seconds that leads to laughing. False starts are normal for Zoom interviews and are easily edited out. But if it happens when live streaming, have a handy tool to re-start on the fly: “Oh, wait, I messed that up, say your name again? Oh, wow, I was really off, eh?” And laugh. But don’t keep laughing. Move on fast. We’re all human. Making mistakes appear normal is the best way to adjust when doing things live. Just prepare accordingly.

Let Them Ask You Questions

Turnabout is fair play!

Encourage your guests to occasionally ask you questions too! This is a great way to ease nerves and sometimes leads to unexpected insights as it puts you as the host in the position of answering a question. During interviews when someone asks me about trends I’m seeing in the community or my experience with building Open Source communities, it often sparks great follow-up discussions. Don’t hog the microphone, though. Get in, move it along, get out.

And don’t be surprised if you feel uncomfortable when this happens! Remember, asking questions isn’t the same experience as answering them! There are many skilled interviewers who aren’t that good at being interviewed! So, characterize the interview as a conversation: “This is just us chatting about your work, so feel free to ask me anything as we move along.” 

Know When to to be Quiet

Shut up!

Try not to speak too much throughout the interview. The guest should be talking about 70% of the time with you prompting them all along the way. You need to find a balance where you can insert yourself in the discussion to offer context to keep things going. Adding a comment here and there to give them a break is also fine. They will appreciate the time to relax. But if you talk too much, the interview will look and sound awkward because the guest will be sitting silent too long and they may look uncomfortable. This is even more awkward when you are doing a live standup hogging the mic and your guest just has to stand there. Very few guests can handle this so don’t put them in this situation. It’s your job to learn how to stand silent while they are doing the majority of the talking. This is where body language comes in really handy. You don’t actually have to stand still. You can move around a bit so your body language helps promote the conversation.

Also, don’t try to one-up your guest. Yes, interviewers do this. It’s amazing. If they tell you about a major outage they caused as their best outrageous story, don’t follow with your own outage story that tops them. Instead: “Wow, that sounds intense. How did you recover from that in such a short time?” Or if you did have a similar experience and want to contribute the story, you could say something like this: “Oh, I ran into something like that, too, so I can relate. But yours was worse!” And laugh. Remember, the guest is the focus of the discussion, not you. You can regularly check the ratio of your voice vs your guest’s voice in any audio editor by just looking at the two wave forms. Yours should have lots of silence throughout the interview, but when you talk it needs to matter.

Sound Quality Matters

Good sound and solid projection.

Although this post isn’t about gear, which requires its own dedicated post, here’s a quick reminder that the sound quality is more important than perfect video when doing podcasts. For remote interviews, insist on decent microphones or headsets. There are many perfectly affordable USB mics that require no setup. They need to be used. I’ve postponed and even canceled interviews when the audio quality was too poor. You can only fix so much in post. And since your goal is to make your guest look good and provide some entertaining content for the community, having bad sound in 2026 isn’t acceptable. It doesn’t have to be perfect. But it can’t be bad. 

Also a sensitive issue related to sound is having to ask guests to assert themselves more. It’s fine to have a headset or a good microphone, but if your guests are too shy to project their voice that’s an issue too. So, just gently ask for more energy! You want them looking and sounding good. Hopefully, they’ll appreciate the thought. Most do. I’ve had to make this request a few times because some developers are naturally shy. But most times you can manage the low energy issue by asking better questions, and asking them to tell stories based on their own personal experiences. The story is the key. That’s what bring out their natural personality. Do that and most projection issues go away.

Handling the Tricky Stuff

Preventing conflicts. 

To prevent people from potentially stumbling on sensitive topics like community conflicts, political issues, or competitive corporate products, just mark these issues out of bounds from the start of the interview. No exceptions. I always make this request, and I’ve never had a guest disagree. We are fortunate that our companies allow us to mix freely in open development communities using company resources, so we ought to keep our conversations focused on the things that are openly approved for public discussion. 

After It’s Over

We’re done. 

Send thank-you notes and let your guests know when the episodes will be live. Encourage them to share it with their networks since developers are obviously well-connected in their communities. Asking for feedback is always nice too. If you don’t want to send a mail afterwards because everyone already has too much mail, that’s fine. Just thank your guest after the conversation and give the publication details. In other words, don’t just end the live interview and disappear. Stop the recording and chat freely for a few minutes to properly say goodbye and wrap up any final details.

The best developer interviews feel like conversations between colleagues, not formal Q&A sessions. When you get it right, you’ll walk away having learned something new, and your audience will feel like they just spent an hour with someone they’d love to grab a coffee with and talk about some code.

Interviews on Java, MySQL, Cloud, Database, and FOSS. Taiwan 2019.

Here’s the article from above stripped down into a short checklist.

Before You Hit Record

Initial Contact

  • Send email explaining format (video/audio), duration, and general topics to set clear expectations and reduce guest anxiety.
  • Do a quick pre-call if the topic is complex or the guest seems nervous so you can uncover interesting stories and build rapport.
  • For Zoom interviews: start recording 15 minutes after joining to chat informally about their latest projects first. This helps guests relax and organizes your thoughts.
  • For live on-site: prep right before recording if the guest is experienced, but allow more time for those who are less comfortable on camera.
  • For complex events (panels, keynotes): layer preparation over multiple touchpoints including emails, group meetings, and rehearsals to ensure everything runs smoothly.
  • Tell guests general topics but don’t provide specific questions to preserve natural, spontaneous responses.
  • Set boundaries on off-limits topics (politics, competitive products, community conflicts) from the start to prevent uncomfortable moments.

Research

  • Check GitHub accounts for recent commits to understand their current technical work.
  • Read their blogs and articles to learn their communication style and key interests.
  • Review conference talks and presentations to identify topics they’re passionate about.
  • Research user group involvement and activities to understand their community contributions.
  • Check recent X, LinkedIn, or mailing list posts to stay current with their latest discussions.
  • Find interesting threads to explore during conversation so you can demonstrate respect and build a genuine connection.

During the Interview

Opening

  • Pre-plan your introduction to start efficiently, especially critical for live streams where you only get one take. But have a transition tool if you do mess up the live stream opening.
  • Jump straight into content after brief introductions. Don’t waste time with forced small talk.
  • Start with their recent work or achievements to engage them immediately with familiar territory.
  • Skip lengthy small talk and forced jokes that create awkward energy instead of authentic connection.

Listening

  • Actually listen in real time. Don’t plan your next question while they’re talking or you’ll create disjointed exchanges.
  • Use checklists to free your mind from technical worries (camera settings, recording status) so you can focus on the conversation.
  • Paraphrase what they said to show you’re following and encourage them to elaborate further.
  • Use body language and verbal cues (“That’s cool!” “Wow!”) to signal genuine interest and keep energy flowing.
  • React authentically to keep the conversation flowing. Forced reactions are obvious and create distance.

Bridging and Flow

  • Comment on what they just said before shifting topics to create seamless transitions.
  • Weave new issues into summaries of previous comments to bridge naturally: “That bug fix sounds complex. How did you approach it with so little time?”
  • Redirect gently if they go off on tangents: “That’s interesting. Hold that thought. I want to go back to your contribution process first…”
  • Use open statements, not just questions (“Tell me more about that”) to create conversational flow rather than interrogation.
  • Make mental notes to circle back to casual mentions they didn’t fully explore.
  • Mix questions, statements, prompts, and body language to make the conversations flow well. This isn’t a Q&A session.

Questioning

  • Ask one question at a time, or at most two directly related questions that build on each other.
  • Never ask compound or disparate multi-part questions that stress out guests, audiences, and yourself.
  • Break complex issues into multiple simple questions and guide guests through each part as they respond.
  • Use open-ended prompts (“Tell me about…”) instead of closed questions (“Was it challenging?”) to encourage storytelling.
  • Avoid leading questions (“Isn’t X better?”) and instead ask “What drew you to that approach?” for more detailed responses.
  • Guide them to explain complex concepts simply: “Break down your testing framework as if you’re explaining it to a new team member. Just a few of the top points.”
  • Let them answer fully before following up. Don’t interrupt their flow.

Story Collection

  • Ask guests beforehand to prepare a few stories so they have time to think about blending narratives into conversation themes.
  • Request funny disasters or dramatic moments (“Tell me about that time you took down the bank on day one”) to reduce stress and engage audiences.
  • Push for vivid sensory details (what they saw, heard, felt) to create scenes that draw listeners in.
  • Ask them to “take you into that scene” to get them reliving the memory rather than just reporting facts.
  • Encourage them to describe moments: “What was it like in that room when you realized what happened? Who was there?”
  • Focus on human elements, not just technical details. Watch how guests light up and become animated when telling real stories they’ve experienced.

Guest Comfort

  • Recognize that being interviewed differs from presenting. Even experienced conference speakers may feel awkward without slides or rehearsals.
  • Frame the interview as a fun chat, not a journalism interview. “This is a mutual discussion. We’re having fun here.”
  • Reassure that pauses/stumbles are normal and editable to create a safe space for authentic responses.
  • Share that you mess up too (introductions, names) to help them relax and feel less pressure.
  • Create safe space for authentic responses, especially for guests who aren’t media trained or don’t have control like they do in their presentations.
  • Adjust for guests who aren’t media trained. Don’t assume they’re skilled at free-flowing live or recorded conversations.

Role Flexibility

  • Encourage guests to ask you questions to ease nerves and spark unexpected insights.
  • Characterize the exchange as a two conversation, not a one way interrogation: “This is just us chatting about your work, so feel free to ask me anything as well.”
  • Expect to feel uncomfortable when you yourself are answering their questions! Asking questions is a different skill than answering them, even for experienced interviewers.

Managing Your Airtime

  • The guest should speak about 70% of the time with you prompting them along the way to keep things moving.
  • Insert yourself only to provide context or keep things going. Add comments here and there to give them breaks.
  • Don’t one-up their stories. If they share a major outage story, respond with “That sounds intense—how did you recover?” not your own outage tale.
  • Stay silent while they talk during live standups. Hogging the mic makes guests look uncomfortable standing there on camera. It’s your job to stand there and NOT look uncomfortable when you are not talking.
  • Check waveforms in post-production. Your waveform should show lots of silence.

Sound Quality

  • Insist on decent microphones or headsets for remote interviews. Affordable USB mics require no setup and must be used.
  • Postpone/cancel if audio quality is too poor. You can only fix so much in post-production, and bad sound is no longer acceptable.
  • Gently ask guests to project more energy if needed. Many developers are naturally shy but you want them sounding good.
  • Use headphones to monitor audio in real time so you can catch problems before they ruin the recording.

Closing

  • Plan your exit strategy because every conversation has a natural lifespan and you need to get out before energy dies.
  • Tell guests upfront you’ll ask for final thoughts so they can prepare something meaningful to end.
  • Use: “Before we wrap up, anything else to add? Any plans coming up?”
  • Keep your closing concise. Don’t drag it out with lengthy summaries unless it feels natural.
  • Thank them and provide episode release date to maintain clarity and goodwill.
  • Get out before energy dies because it will be obvious to listeners if you linger too long.

After the Interview

Follow-Up

  • Send a thank-you note to reinforce goodwill and maintain professional relationships.
  • Confirm episode release date so they know when to expect and share the content.
  • Encourage sharing within their networks since developers are well-connected in their communities.
  • Ask for feedback (“Any suggestions for how I could make these conversations better?”) to build long-term relationships and to learn yourself.
  • Or: Skip the final email. But don’t just disappear. Stop recording and chat freely for a few minutes to properly say goodbye
  • Maintain momentum for future collaboration and potential referrals to other interesting guests.

Obviously, this isn’t an exhaustive list of issues to consider. But it’s a good start. Cheers.

Duke’s Corner: The Final Archive

Here are all 77 podcasts I did for Duke’s Corner from 2022 to 2026. It was my great pleasure to interview all of these wonderful Java developers who spoke so passionately about the technology and the community over the years. All of your stories were amazing and inspiring! I loved every single conversation! Sadly, though, for me it’s all over now. Must make way for prompts and inference, I guess. But maybe we’ll meet again sometime soon. And thank you for all the nice comments on LinkedIn and X. Duke’s Corner Podcasts: https://grisanzio.com/duke/

Carlos Obregón at JavaOne 2026

Carlos Obregón at JavaOne 2026 | July 3, 2026 | Duke’s Corner Java Podcast

Here’s the sixth and final interview I did at JavaOne 2026 back in March. Carlos is a Java Champion and also the founder of Bogota’s Java User Group, Bogotá JVM. Carlos has been running monthly meetups for over a decade, and he and his colleagues have built one of the most active developer communities in Latin America. In his session at JavaOne — Teaching Java as a First Language: Lessons from Three Years of a Real-World Bootcamp — he outlined a free, online, 13-week week program for learning Java. The bootcamp started in Colombia but then quickly expanded to include multiple JUGs in Latin American.

“Java is the best language for this” he said. The community, the tooling, the syntax, the readability of the language itself — everything pointed in the right direction. And the students in the bootcamp agree. “They love Java” he said. Carlos started out programming in C++ in school, but from the moment he finally picked up Java it was obviously different. “It was Love at first sight” he said.

Carlos also advises that developers embrace AI. “Think of it like your pair programming buddy,” he said. But he said to go deeply into programming fundamentals first because if you can’t evaluate what the AI produces then you may end up shipping bugs you don’t understand.

JavaOne was an amazing experience for Carlos. It was his first JavaOne, but he’ll be back for sure.