Speech-to-text transcript of the AutoContent API example "report-pdf-to-podcast" (Whisper large-v3-turbo, not edited; no speaker labels). Okay, let's unpack this. Imagine, like, you just finished catering this massive wedding, right? Oh, that sounds exhausting. It is. The food is a total hit. People are raving about it. But when guests ask the bride who cooked it all, she just kind of shrugs and murmurs, you know, the food was good. Yeah, that is definitely rough. Right. But honestly, that is exactly how the scientific community is treating you and your research software team right now. The labor is completely consumed, but the credit just, you know, vanishes into thin air. It really does. So welcome to today's deep dive. Our mission today is a brief specifically for you, the software teams on the ground. We are breaking down a 2026 paper on software citation best practices, because frankly, the current system is totally broken and we need to talk about how your team can fix it today. We do. And you know, the Vanishing Act is just staggering when you actually look at the numbers. The paper we are looking at details a manual review of 90 biology articles. Okay, 90 articles. Right. And the researchers found that only, I think it was 31 to 43 percent of software mentions included a formal citation. Wow. So less than half even get a proper mention. Exactly. But it gets worse. Of that tiny fraction that actually did cite something, 84 to 89 percent pointed to a traditional written paper about the software, not the actual software itself. Wait, really? So even when researchers try to do the right thing, they are, well, they are completely missing the actual target. Precisely. And for a software team, getting this right isn't just about ego, right? It is about attribution. Which is what actually pays the bills. Exactly. Attribution directly drives your team's sustainability. I mean, when you can definitively prove your software is being used, you can secure funding. You justify your team's existence. Plus, it guarantees reproducibility. Because it points to the exact version they used. Yes. A proper citation points a future researcher to the exact computational environment someone used. And that is, well, it is the baseline requirement for verifiable science. And here are the logic there. Totally. But let me push back a little bit. Like, if we stop pointing users to the original method paper, don't we lose that centralized citation count on Google Scholar? That is a very common worry. Yeah. Right, because that H-index, the metric that universities and funders use to measure a researcher's overall productivity, it relies heavily on traditional paper citations. So, you know, why reinvent the wheel if citing the paper is what actually pays the bills? Well, what's fascinating here is that that argument ignores the fundamental nature of what you build. A published paper is like a static PDF. It doesn't change. Once it is out, it is out. Exactly. But software is this living, evolving ecosystem. Imagine a junior developer joins your team and writes a crucial algorithm, say, a year after your main method paper is published. Oh, I see where this is going. Yeah. If users are only citing that original PDF, they are completely cutting that new contributor out of the credit loop entirely. That is a huge blind spot. By tying a living project to a dead PDF, you just freeze the credit in time while the actual work keeps moving forward. Right. A paper citation structurally fails to capture the ongoing collaborative reality of your development cycle. Okay, so what does this all mean? Practically speaking, what should this team do right now to fix it without adding like hours of administrative overhead to their week? So the paper outlines two immediate, highly actionable steps. First, you need a persistent identifier or a PID. Okay, and what is the standard way to do that? The standard approach here is archiving your source code on a repository like Zenodo. And what is great is how automated this can be if you use semantic versioning. That is the one where you label updates with major, minor, and patch numbers, right? Exactly, to communicate exactly what kind of changes you made. If you do that, you can link your GitHub repository directly to Zenodo. Oh, nice. Yeah. So every time you push a new release, Zenodo automatically mints a specific digital object identifier, a DOI, for that exact version. Meaning every distinct iteration of your code gets its own permanent, searchable address on the internet automatically. Spot on. And then the second step is making sure people actually use that DOI. You need to provide machine-actionable instructions. Machine-actionable. How so? Well, you place a file called citation.cff into the root level of your source code and update your readme to point to it. What exactly does a CFF file do under the hood? Like, why that specific format? It stands for citation file format. It is written in YAML, which is a human-readable data format. Right. I know YAML. So when you place that .cff file in your root directory, GitHub's backend instantly parses those YAML tags. Things like author names, the version number, the release date, and your new Zenodo DOI. Ah, and it uses all that metadata to make it easy for the user. Exactly. GitHub natively reads this and automatically generates a formatted cite this repository widget right on the sidebar of your project page. That is brilliant. Yeah. So instead of hoping a user like digs through a manual to figure out how to credit you, you are having the platform instantly generate the exact citation block. Yep. They just copy and paste. You are making correct attribution the absolute path of least resistance. And if we connect this to the bigger picture, when you combine those technical mechanics, you know, automating the DOI and generating the widget, you help force a massive cultural shift. Because it makes the code a first-class citizen. Right. By making software as strictly citable as a journal article, you are retraining the scientific community to value computational labor on the exact same level as traditional research. Which is so long overdue. Taking control of your own metadata is incredibly powerful. But, you know, it does leave a lingering question as we look ahead. Oh? What is that? Well, as AI models increasingly automate the research and citation process, sweeping up code and generating citations on the fly, if software citation generation becomes completely machine-driven, will human developers eventually lose the final say in how their intellectual labor is categorized and valued by the scientific community? That is a slightly terrifying thought. Will the algorithms be the ones deciding who gets the credit? It is definitely something for you and your team to ponder as you commit your next line of code.