{"id":606485,"date":"2025-07-02T14:27:46","date_gmt":"2025-07-02T19:27:46","guid":{"rendered":"https:\/\/towardsdatascience.com\/?p=606485"},"modified":"2025-07-02T14:28:00","modified_gmt":"2025-07-02T19:28:00","slug":"software-engineering-in-the-llm-era","status":"publish","type":"post","link":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/","title":{"rendered":"Software Engineering in the LLM Era"},"content":{"rendered":"\n

In the broad software<\/mdspan> engineering space, debates about whether using LLMs in coding is a good or a bad idea are raging. On the extremes, there are some people who think that any use of LLMs in coding is indefensible, and other people are ready to throw out the whole field of software engineering as too expensive and unnecessary. I\u2019m fascinated by this discussion, particularly from my sociologist\u2019s perspective, because so much of the conversation seems to be about whether<\/a> an LLM<\/a> is useful<\/a>. Is it so fatally flawed that it\u2019s a total waste of time, or is it so unimaginably powerful that it\u2019s a fool\u2019s errand to avoid it? Instead of thinking about it so narrowly, I actually really want to talk about the broader context of software engineering in the context of LLM technology. (I consider software engineering only adjacent to my field of machine learning engineering, but I have worked alongside many extremely talented SWEs in my career, at tech companies of various sizes, and I\u2019ve had the chance to observe the role quite closely. Some of the analysis below also applies to the MLE field, but not all of it.)<\/p>\n\n\n\n

Context<\/h2>\n\n\n\n

During my own career I\u2019ve seen a lot change in the American tech economy, and in the way the job of \u201ccoding\u201d has been perceived and described. It\u2019s a bit of a trope but it was certainly true for a period of time that \u201clearning to code\u201d was touted as the fastest way to a white collar career with a steady paycheck and future-proof prospects, both for young people and for career-changers trying to find a place in the shifting economy. Coding bootcamps came and (mostly) went<\/a>, for a time giving people a relatively quick way to gain the foundational skills of the job.<\/p>\n\n\n\n

In many fields, however, shortages of qualified employees can swiftly turn into a glut of talent with nowhere to go (ask lawyers), especially when high or at least comfortable salaries are on offer. While some people think this is happening in software engineering, it\u2019s not clear if that\u2019s necessarily the case yet, because there are other factors in play too. In the mid-2010s, many tech companies and startups were scrambling for hyper-growth and hiring as fast as possible, using cheap venture capital to fund their expansions without regard for profitability, but that\u2019s definitively over now. Tech layoffs, including many software engineers, exploded in the years immediately following the start of the COVID pandemic, in large part as a response to the unsustainable hiring of preceding years and the sudden jolt to the economy of lockdowns. After that period of layoffs, hiring for SWE talent slowed in many sectors. Developer skillsets are diversifying and specializing, so there may still be sub-fields with strong hiring, but a lot of young SWEs in particular are struggling to break in.<\/p>\n\n\n\n

Junior vs Senior<\/h2>\n\n\n\n

This brings us around to now. Some people argue that there aren\u2019t too many software engineers, but there are too many inexperienced or junior software engineers, and that employers are still desperate for experienced hires. What does that really mean? Is it true? Without doing academic research to really investigate (if anyone has done good research on this question, please send it to me!), we can still take a look at the issues involved. First, let\u2019s define terms.<\/p>\n\n\n\n

\n

I\u2019m not using anybody\u2019s in-house leveling terms, or talking about job titles here, but I want to clarify what the differences might be in someone\u2019s role depending on the experience and skills they bring.<\/p>\n<\/blockquote>\n\n\n\n

A junior SWE is someone who needs quite a bit of support, coaching, and managing to produce good quality work. They\u2019re not yet at a place of working independently or mentoring others. They are still learning how the job is done. This doesn\u2019t mean they don\u2019t produce value! Junior engineers do write code and get work done, and they can often learn very quickly and become more productive. However, a senior SWE is someone who can be expected to work mostly independently, with minimal supervision required for good work to be done and goals to be met, and they can be relied on to help those junior folks along. They start to be able to solve more difficult problems, write elegant code that is high quality, and even begin being part of strategy conversations about how to build your whole codebase for the long haul.<\/p>\n\n\n\n

This is more or less the pattern for most skilled professions\u200a\u2014\u200ayou\u2019ll learn some amount of what you need to know from schooling or training, but you really learn how to be a member of the profession and do the job from experience and practice. There\u2019s no set rule about how much time it takes for you to go from junior to senior in this framework, because it\u2019s all about what you can do and the capabilities you have. Your perceived value as a worker (and your pay) go up as you get better at the job over time.<\/p>\n\n\n\n

LLMs Enter Stage Left<\/h2>\n\n\n\n

With this, we can start to inquire about how that shifts, and how the existence of LLMs and LLM based coding tools actually may (to use a cliche) disrupt the context of the profession now.<\/p>\n\n\n\n

As an individual, if you\u2019re a senior SWE, you might find an LLM tool like Github Copilot or Cursor handy for doing scut work, such as getting unit tests working, writing basic docs, or sketching out the start of a project that you\u2019ll then fill in based on your own knowledge. However, your own knowledge is really vital for this to be effective. As we in machine learning will tell you, LLM output is probabilistic at its core. If the training data has many examples of code that are relevant to what you\u2019re doing, it\u2019s going to be reasonably likely to produce code for you that works. But sooner or later (probably sooner) it\u2019s going to generate something that won\u2019t work. That might be failing loudly or failing silently, it might be opening up a security hole, or it might just be a suboptimal way of doing a task. The thing that matters at that point is what you do in response.<\/p>\n\n\n\n

Assuming you are a senior SWE with significant experience writing all this stuff by hand yourself, you have the skills to spot the mistakes, and figure out how to fix them smoothly so the end product works well. The LLM probably makes you more productive in the end, because you could abstract away some of the work that isn\u2019t interesting and doesn\u2019t require much thought. If you\u2019re not a senior person, well, then you may end up going back to the LLM to ask it to fix its own mistakes. And it might do that, but there\u2019s always a risk of another mistake being introduced, and on down the road. There\u2019s really no telling how long this could take, and it\u2019s hard to compare the time with how long it would have taken you to learn the underlying code and just solve it yourself.<\/p>\n\n\n\n

However, lots of people will argue that the LLM repeating workflow is fine. People may believe that just being there to click the hover button to tell Copilot to \u201cFix\u201d over and over again is sufficient, even if it\u2019s not a particularly satisfying job. However, there are serious arguments to be made that the output will be seriously flawed, whether in readability, maintainability, security holes, or other aspects.<\/p>\n\n\n\n

\n

\u201cSure, Gen AI supercharges development, but it also supercharges risk. Two engineers can now churn out the same amount of insecure, unmaintainable code as 50 engineers.\u201d\u200a\u2014\u200a<\/em>https:\/\/www.zdnet.com\/article\/10-professional-developers-on-vibe-codings-true-promise-and-peril\/<\/a><\/p>\n<\/blockquote>\n\n\n\n

This question has been addressed by many writers recently. However, I\u2019m less interested at this moment in whether Copilot can get to the desired result eventually than I am in what this process and way of working does to us.<\/p>\n\n\n\n

Broaden the Aperture<\/h2>\n\n\n\n

Remember that we\u2019re here to talk about the effect of the LLM on the profession. In the pre-AI era, a junior engineer would start working on a ticket, and make some mistakes, introduce a bug or two, and they\u2019d basically be armed with StackOverflow and the docs, plus peers to collaborate with for help, to figure out how to get it right. Once they muddled through and got the code working, they\u2019d make a PR and get feedback from more experienced peers, who would offer recommendations and corrections. Once those corrections were made, a PR could be approved and merged.<\/p>\n\n\n\n

I think the \u201cmuddling through\u201d part of this process is actually pedagogically and professionally quite important. Once you\u2019ve passed through the academic preparation for the software engineering role, the practical preparation is what you need to develop the capabilities to grow. I am a strong believer in the idea that making mistakes and fixing them is a tremendously valuable way to learn. Once the junior dev working on that bit of code has worked hard, fixed their own bugs, written the tests and docs, and gone through PR review, they know that bit of code better than any other person around. That process is the productive cognitive labor that brings them a step closer to being an engineer who can work independently, and take on more senior responsibilities successfully.<\/p>\n\n\n\n

On Being Efficient<\/h2>\n\n\n\n

However, from the outside, this process looks slow. It looks like they had to spend a lot of time flailing around to just get to the end result of code that works, and surely it would be more efficient to either just make an LLM do it, or make a senior dev do it?<\/p>\n\n\n\n

If efficiency is your only criteria, then sure, maybe this is true. But I want to push back strongly on the premise. We do lots of things without thinking about broader context or impact, especially in the tech industry, and prioritizing efficiency today at all costs is a recipe for future disaster. Let\u2019s spin out the narrative a bit\u200a\u2014\u200aif efficiency is the priority, either we have an LLM do the bulk of the work, or a senior dev does it, or maybe a bit of both, like an LLM does the first stab and a senior dev reviews it. Setting aside any questions of quality (about which there should be questions), what\u2019s the role of a junior SWE in this space?<\/p>\n\n\n\n

Does a junior SWE watch the LLM do most of the coding? Do they just exist as an observer? Do they click \u201cok\u201d from time to time as the LLM goes along, exemplifying \u201cvibe coding\u201d? Or do they not exist at all in this scenario? Loud voices in the AI space certainly are arguing that they disappear altogether<\/a>. If so, in the immediate moment, employers in tech save a significant amount of money on salaries, so stock price goes up.<\/p>\n\n\n\n

\n

The idea of vibe coding is using an LLM based tool to write the code for your project, with minimal actual hand-writing of code involved. The name comes from the principle that you behind the keyboard have a general sense of the \u201cvibe\u201d of what you want your result to be, but you either don\u2019t know how to do it yourself or don\u2019t want to do it yourself, so you\u2019re outsourcing the cognitive work of coding to a computer. You\u2019ll just describe the broad strokes of what you want, in human language, and let the LLM figure out a way to achieve that through code.<\/p>\n<\/blockquote>\n\n\n\n

Hollowing<\/h2>\n\n\n\n

However, we know that a healthy profession needs to be bringing in new talent as senior staff progress and eventually retire. Senior engineers are still being sought after, because they can solve the problems and write the complex code that neither junior devs nor LLMs can produce. Their experience and skills are undeniably valuable and necessary to good software being produced. But where do we think senior engineers come from? Just like senior doctors, or senior attorneys, they start out as junior people. Their capabilities must be acquired through experience.<\/p>\n\n\n\n

If we build a working environment where junior software engineers no longer exist, we are hollowing out the pipeline of talent the profession needs. Instead of having a funnel of talent from academic study into the field, young people have no real way to get to the level of experience that is in highest demand.<\/p>\n\n\n\n

Conclusions<\/h2>\n\n\n\n

I appreciate readers coming along with me on this discussion, because it\u2019s important to think about the technology we make ubiquitous not just from our own individual perspectives but from a broader view. How we employ LLM technology in the field of software engineering will have a serious impact on the future of the profession and what it looks like\u200a\u2014\u200aand, I\u2019d argue, this is true for many other fields as well where incorporating LLMs is becoming fashionable. I\u2019m not arguing for zero LLM usage in coding, by any means\u200a\u2014\u200ait can be incredibly useful if you have the experience and skills to make the most of it. (There are many important conversations to have about how it may impact our skill levels and the maintenance of our skills, but that\u2019s a different topic for another day.)<\/p>\n\n\n\n

But in any profession, senior practitioners don\u2019t just appear\u200a\u2014\u200athey\u2019re created, and that process of creation takes work and time, and may not be the most immediately \u201cefficient\u201d thing to do. Efficiency in the immediate moment just isn\u2019t the most important thing\u200a\u2014\u200ait can\u2019t be, if we want the future to be bright.<\/p>\n\n\n\n

\n\n\n\n

I am speaking at two events in July 2025, including a free virtual conference called “Agents in Production”<\/a> \u2014 please sign up if you’re interested!<\/p>\n\n\n\n

Read more of my work at www.stephaniekirmer.com<\/a>.<\/p>\n\n\n\n

\n\n\n\n

Further Reading<\/h3>\n\n\n\n

AI Killed My Job: Tech workers<\/strong>
Tech workers at TikTok, Google, and across the industry share stories about how AI is changing, ruining, or replacing\u2026<\/em>www.bloodinthemachine.com<\/a><\/a><\/p>\n\n\n\n

10 professional developers on vibe coding’s true promise and peril<\/strong>
Is vibe coding the future of software or a security nightmare in disguise? Here’s what experienced developers think\u2026<\/em>www.zdnet.com<\/a><\/a><\/p>\n\n\n\n

Frontiers | Some Evidence on the Cognitive Benefits of Learning to Code<\/strong>
Please see the submitted files.<\/em>www.frontiersin.org<\/a><\/a><\/p>\n\n\n\n

Trusting your own judgement on ‘AI’ is a huge risk<\/strong>
Web dev at the end of the world, from Hverager\u00f0i, Iceland<\/em>www.baldurbjarnason.com<\/a><\/a><\/p>\n\n\n\n

Jones, Capers. 2014. The Technical and Social History of Software Engineering.<\/p>\n\n\n\n

Layoffs.fyi\u200a\u2014\u200aTech Layoff Tracker and DOGE Layoff Tracker<\/strong>
LIVE] Tracking all tech startup layoffs\u200a\u2014\u200aand lists of employees laid off\u200a\u2014\u200asince COVID-19 was declared a pandemic\u2026<\/em>layoffs.fyi<\/a><\/a><\/p>\n\n\n\n

https:\/\/www.trueup.io\/layoffs<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

On growing new software engineers, even when it\u2019s inefficient<\/p>\n","protected":false},"author":18,"featured_media":606486,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"is_member_only":false,"sub_heading":"On growing new software engineers, even when it\u2019s inefficient","footnotes":""},"categories":[21],"tags":[447,644,453,491,530],"sponsor":[],"coauthors":[31187],"class_list":["post-606485","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-large-language-models","tag-artificial-intelligence","tag-careers","tag-editors-pick","tag-programming","tag-software-engineering"],"yoast_head":"\nSoftware Engineering in the LLM Era | Towards Data Science<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Software Engineering in the LLM Era | Towards Data Science\" \/>\n<meta property=\"og:description\" content=\"On growing new software engineers, even when it\u2019s inefficient\" \/>\n<meta property=\"og:url\" content=\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\" \/>\n<meta property=\"og:site_name\" content=\"Towards Data Science\" \/>\n<meta property=\"article:published_time\" content=\"2025-07-02T19:27:46+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-07-02T19:28:00+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"800\" \/>\n\t<meta property=\"og:image:height\" content=\"533\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Stephanie Kirmer\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@TDataScience\" \/>\n<meta name=\"twitter:site\" content=\"@TDataScience\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Stephanie Kirmer\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\"},\"author\":{\"name\":\"TDS Editors\",\"@id\":\"https:\/\/towardsdatascience.com\/#\/schema\/person\/f9925d336b6fe962b03ad8281d90b8ee\"},\"headline\":\"Software Engineering in the LLM Era\",\"datePublished\":\"2025-07-02T19:27:46+00:00\",\"dateModified\":\"2025-07-02T19:28:00+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\"},\"wordCount\":2497,\"publisher\":{\"@id\":\"https:\/\/towardsdatascience.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg\",\"keywords\":[\"Artificial Intelligence\",\"Careers\",\"Editors Pick\",\"Programming\",\"Software Engineering\"],\"articleSection\":[\"Large Language Models\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\",\"url\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\",\"name\":\"Software Engineering in the LLM Era | Towards Data Science\",\"isPartOf\":{\"@id\":\"https:\/\/towardsdatascience.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg\",\"datePublished\":\"2025-07-02T19:27:46+00:00\",\"dateModified\":\"2025-07-02T19:28:00+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage\",\"url\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg\",\"contentUrl\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg\",\"width\":800,\"height\":533,\"caption\":\"Photo by Francesco Gallarotti on Unsplash\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/towardsdatascience.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Software Engineering in the LLM Era\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/towardsdatascience.com\/#website\",\"url\":\"https:\/\/towardsdatascience.com\/\",\"name\":\"Towards Data Science\",\"description\":\"Publish AI, ML & data-science insights to a global community of data professionals.\",\"publisher\":{\"@id\":\"https:\/\/towardsdatascience.com\/#organization\"},\"alternateName\":\"TDS\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/towardsdatascience.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/towardsdatascience.com\/#organization\",\"name\":\"Towards Data Science\",\"alternateName\":\"TDS\",\"url\":\"https:\/\/towardsdatascience.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/towardsdatascience.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/02\/tds-logo.jpg\",\"contentUrl\":\"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/02\/tds-logo.jpg\",\"width\":696,\"height\":696,\"caption\":\"Towards Data Science\"},\"image\":{\"@id\":\"https:\/\/towardsdatascience.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/TDataScience\",\"https:\/\/www.youtube.com\/c\/TowardsDataScience\",\"https:\/\/www.linkedin.com\/company\/towards-data-science\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/towardsdatascience.com\/#\/schema\/person\/f9925d336b6fe962b03ad8281d90b8ee\",\"name\":\"TDS Editors\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/towardsdatascience.com\/#\/schema\/person\/image\/23494c9101089ad44ae88ce9d2f56aac\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g\",\"caption\":\"TDS Editors\"},\"description\":\"Building a vibrant data science and machine learning community. Share your insights and projects with our global audience: bit.ly\/write-for-tds\",\"url\":\"https:\/\/towardsdatascience.com\/author\/towardsdatascience\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Software Engineering in the LLM Era | Towards Data Science","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/","og_locale":"en_US","og_type":"article","og_title":"Software Engineering in the LLM Era | Towards Data Science","og_description":"On growing new software engineers, even when it\u2019s inefficient","og_url":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/","og_site_name":"Towards Data Science","article_published_time":"2025-07-02T19:27:46+00:00","article_modified_time":"2025-07-02T19:28:00+00:00","og_image":[{"width":800,"height":533,"url":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg","type":"image\/jpeg"}],"author":"Stephanie Kirmer","twitter_card":"summary_large_image","twitter_creator":"@TDataScience","twitter_site":"@TDataScience","twitter_misc":{"Written by":"Stephanie Kirmer","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#article","isPartOf":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/"},"author":{"name":"TDS Editors","@id":"https:\/\/towardsdatascience.com\/#\/schema\/person\/f9925d336b6fe962b03ad8281d90b8ee"},"headline":"Software Engineering in the LLM Era","datePublished":"2025-07-02T19:27:46+00:00","dateModified":"2025-07-02T19:28:00+00:00","mainEntityOfPage":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/"},"wordCount":2497,"publisher":{"@id":"https:\/\/towardsdatascience.com\/#organization"},"image":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage"},"thumbnailUrl":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg","keywords":["Artificial Intelligence","Careers","Editors Pick","Programming","Software Engineering"],"articleSection":["Large Language Models"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/","url":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/","name":"Software Engineering in the LLM Era | Towards Data Science","isPartOf":{"@id":"https:\/\/towardsdatascience.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage"},"image":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage"},"thumbnailUrl":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg","datePublished":"2025-07-02T19:27:46+00:00","dateModified":"2025-07-02T19:28:00+00:00","breadcrumb":{"@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#primaryimage","url":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg","contentUrl":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/07\/plant.jpg","width":800,"height":533,"caption":"Photo by Francesco Gallarotti on Unsplash"},{"@type":"BreadcrumbList","@id":"https:\/\/towardsdatascience.com\/software-engineering-in-the-llm-era\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/towardsdatascience.com\/"},{"@type":"ListItem","position":2,"name":"Software Engineering in the LLM Era"}]},{"@type":"WebSite","@id":"https:\/\/towardsdatascience.com\/#website","url":"https:\/\/towardsdatascience.com\/","name":"Towards Data Science","description":"Publish AI, ML & data-science insights to a global community of data professionals.","publisher":{"@id":"https:\/\/towardsdatascience.com\/#organization"},"alternateName":"TDS","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/towardsdatascience.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/towardsdatascience.com\/#organization","name":"Towards Data Science","alternateName":"TDS","url":"https:\/\/towardsdatascience.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/towardsdatascience.com\/#\/schema\/logo\/image\/","url":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/02\/tds-logo.jpg","contentUrl":"https:\/\/towardsdatascience.com\/wp-content\/uploads\/2025\/02\/tds-logo.jpg","width":696,"height":696,"caption":"Towards Data Science"},"image":{"@id":"https:\/\/towardsdatascience.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/TDataScience","https:\/\/www.youtube.com\/c\/TowardsDataScience","https:\/\/www.linkedin.com\/company\/towards-data-science\/"]},{"@type":"Person","@id":"https:\/\/towardsdatascience.com\/#\/schema\/person\/f9925d336b6fe962b03ad8281d90b8ee","name":"TDS Editors","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/towardsdatascience.com\/#\/schema\/person\/image\/23494c9101089ad44ae88ce9d2f56aac","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","caption":"TDS Editors"},"description":"Building a vibrant data science and machine learning community. Share your insights and projects with our global audience: bit.ly\/write-for-tds","url":"https:\/\/towardsdatascience.com\/author\/towardsdatascience\/"}]}},"distributor_meta":false,"distributor_terms":false,"distributor_media":false,"distributor_original_site_name":"TDS Contributor Portal","distributor_original_site_url":"https:\/\/contributor.insightmediagroup.io","push-errors":false,"_links":{"self":[{"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/posts\/606485","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/users\/18"}],"replies":[{"embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/comments?post=606485"}],"version-history":[{"count":0,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/posts\/606485\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/media\/606486"}],"wp:attachment":[{"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/media?parent=606485"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/categories?post=606485"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/tags?post=606485"},{"taxonomy":"sponsor","embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/sponsor?post=606485"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/towardsdatascience.com\/wp-json\/wp\/v2\/coauthors?post=606485"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}