{"id":14438,"date":"2025-06-02T09:00:00","date_gmt":"2025-06-02T09:00:00","guid":{"rendered":"https:\/\/codeaura.ai\/?p=14438"},"modified":"2025-06-02T13:03:13","modified_gmt":"2025-06-02T13:03:13","slug":"how-to-onboard-new-engineers-into-40-year-old-systems-without-losing-your-mind","status":"publish","type":"post","link":"https:\/\/codeaura.ai\/fr\/how-to-onboard-new-engineers-into-40-year-old-systems-without-losing-your-mind\/","title":{"rendered":"How to Onboard New Engineers Into 40-Year-Old Systems (Without Losing Your Mind)"},"content":{"rendered":"<div data-elementor-type=\"wp-post\" data-elementor-id=\"14438\" class=\"elementor elementor-14438\">\n\t\t\t\t\t\t\t<div class=\"elementor-element elementor-element-22169526 e-flex e-con-boxed e-con e-parent\" data-id=\"22169526\" data-element_type=\"container\" data-settings=\"{&quot;content_width&quot;:&quot;boxed&quot;}\" data-core-v316-plus=\"true\">\n\t\t\t\t\t<div class=\"e-con-inner\">\n\t\t\t\t<div class=\"elementor-element elementor-element-468c61de elementor-widget elementor-widget-text-editor\" data-id=\"468c61de\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t<style>\/*! elementor - v3.17.0 - 08-11-2023 *\/\n.elementor-widget-text-editor.elementor-drop-cap-view-stacked .elementor-drop-cap{background-color:#69727d;color:#fff}.elementor-widget-text-editor.elementor-drop-cap-view-framed .elementor-drop-cap{color:#69727d;border:3px solid;background-color:transparent}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap{margin-top:8px}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap-letter{width:1em;height:1em}.elementor-widget-text-editor .elementor-drop-cap{float:left;text-align:center;line-height:1;font-size:50px}.elementor-widget-text-editor .elementor-drop-cap-letter{display:inline-block}<\/style>\t\t\t\t<h4>The Legacy Paradox: Critical Yet Crumbling<\/h4>\n<p>It\u2019s 2025, and your organization still depends on a system built in 1985. It handles millions of transactions per day, controls supply chains, processes health claims, or manages core banking functions. And yet, the codebase is monolithic, undocumented, and written in a language no one under 40 has ever used in production.<\/p>\n<p>Welcome to the legacy paradox: the most critical systems in your organization are also the most fragile\u2014and onboarding new engineers into them is a process that tests patience, nerves, and retention rates.<\/p>\n<p>Despite widespread cloud adoption, over 70% of enterprise systems still rely on legacy platforms in some form. These aren\u2019t just background tools\u2014they are often core revenue engines. But because they were built decades ago, they come with built-in disadvantages:<\/p>\n<ul>\n<li>Ancient languages like COBOL, FORTRAN, or Assembly<\/li>\n<li>Sparse or outdated documentation<\/li>\n<li>Layers of undocumented patches and workarounds<\/li>\n<li>Retired or soon-to-retire developers who \u201cknew how everything worked\u201d<\/li>\n<\/ul>\n<p>The challenge isn\u2019t just maintaining these systems\u2014it\u2019s bringing new people into them. Every onboarding cycle becomes a fire drill, relying on tribal knowledge, verbal walkthroughs, and &#8220;read the code until it makes sense&#8221; survival tactics.<\/p>\n<p>The result? Weeks or months of unproductive ramp-up time, frustrated engineers, and a growing backlog of critical features and fixes that never get done.<\/p>\n<p>This article is your survival guide\u2014not just for onboarding engineers into legacy systems, but for doing it without losing your mind, your team, or your competitive edge.<\/p>\n<h4>Institutional Knowledge is Disappearing<\/h4>\n<p><em>The human bottleneck in legacy system understanding<\/em><\/p>\n<p>For decades, companies relied on a small group of legacy experts to keep the lights on. These were the engineers who knew where the critical logic lived, which &#8220;temporary&#8221; patch from 1997 was still active, and why certain subsystems must never be touched.<\/p>\n<p>But there\u2019s a problem: they\u2019re retiring\u2014and they\u2019re not being replaced.<\/p>\n<p>According to recent industry data, 68% of COBOL developers will retire by 2025, and fewer than 5% of new computer science graduates are learning legacy languages. The resulting knowledge gap isn\u2019t just technical\u2014it\u2019s operational.<\/p>\n<p>What\u2019s at risk:<\/p>\n<ul>\n<li>Loss of undocumented business logic: Millions of lines of code govern mission-critical decisions, yet no one can explain why they behave the way they do.<\/li>\n<li>Failed audits and compliance gaps: Legacy systems often lack traceability or documentation, increasing regulatory risk.<\/li>\n<li>Longer downtime and slower incident response: When something breaks, and the expert is gone, recovery can take exponentially longer.<\/li>\n<\/ul>\n<p>In many organizations, knowledge is passed like folklore\u2014through shadowing, hallway conversations, or brittle handover documents. And while this worked when teams were stable, it crumbles under today\u2019s churn rates, remote work models, and fast-moving product cycles.<\/p>\n<p>The result? New engineers aren\u2019t just onboarding\u2014they\u2019re entering a black box.<\/p>\n<p>To survive, enterprises need to rethink how knowledge is captured, transferred, and made actionable. The good news: we no longer need to rely solely on humans to document and explain 40-year-old codebases. AI has changed the equation.<\/p>\n<h4>The New Engineer\u2019s Dilemma<\/h4>\n<p>What it\u2019s like stepping into undocumented, mission-critical codebases<\/p>\n<p>Imagine you&#8217;re a mid-level software engineer hired to help maintain a mission-critical mainframe system. On day one, you&#8217;re handed a login, a 3GB ZIP file of COBOL code, and a vague warning: \u201cDon\u2019t touch the billing module. No one\u2019s sure how it works.\u201d<\/p>\n<p>Welcome to legacy onboarding.<\/p>\n<p>New engineers are often expected to:<\/p>\n<ul>\n<li>Read unfamiliar, procedural code with no comments<\/li>\n<li>Reverse-engineer business logic from nested conditionals<\/li>\n<li>Guess at data flows across multiple interdependent systems<\/li>\n<li>Navigate internal acronyms and tribal processes undocumented anywhere<\/li>\n<\/ul>\n<p>And they must do this without breaking anything, in a high-stakes environment where uptime, compliance, and customer trust are non-negotiable.<\/p>\n<p>This creates three painful dilemmas:<\/p>\n<ol>\n<li>Confidence vs. Risk: Engineers can\u2019t contribute meaningfully until they understand the system, but experimenting risks production failure.<\/li>\n<li>Speed vs. Safety: Leaders want quick ramp-up, but rushing onboarding leads to rework, bugs, and even data loss.<\/li>\n<li>Autonomy vs. Gatekeeping: Legacy experts are protective of their domain, unintentionally slowing knowledge transfer with siloed know-how.<\/li>\n<\/ol>\n<p>The emotional toll is real. Talented developers join with energy, only to feel lost, frustrated, or discouraged. Many leave\u2014not because they lack skills, but because the system lacks clarity.<\/p>\n<p>The answer isn\u2019t throwing more time or people at the problem. It\u2019s redesigning onboarding to meet engineers where they are\u2014and giving them tools to succeed from day one.<\/p>\n<p>Next, we\u2019ll look at the most common mistakes companies make\u2014and how to avoid them.<\/p>\n<h4>Five Common Onboarding Mistakes<\/h4>\n<p>From firehose dumping to tribal gatekeeping<\/p>\n<p>Even the most well-intentioned teams often sabotage their own onboarding efforts\u2014especially when it comes to legacy systems. Here are five of the most common and costly mistakes:<\/p>\n<p><strong>The \u201cFirehose\u201d Knowledge Dump<\/strong><\/p>\n<p>New hires are bombarded with 40 years of undocumented history in the first week\u2014architecture diagrams, outdated wiki links, and verbal war stories from senior staff. None of it is contextual, and most of it won\u2019t stick.<\/p>\n<p>Result: Cognitive overload, low retention, and the illusion of knowledge transfer.<\/p>\n<p><strong>Shadowing Without Structure<\/strong><\/p>\n<p>\u201cJust follow Alice around for two weeks\u201d sounds helpful, until you realize Alice does everything from bug fixes to late-night prod hotfixes\u2014and isn\u2019t trained to teach.<\/p>\n<p>Result: Inconsistent experience, gaps in coverage, and frustration on both sides.<\/p>\n<p><strong>Tribal Gatekeeping<\/strong><\/p>\n<p>Legacy systems are often guarded by longtime developers who unconsciously create barriers to access\u2014either by hoarding knowledge or by being too busy to explain anything twice.<\/p>\n<p>Result: New engineers hesitate to ask questions, leading to slow ramp-up and rising attrition.<\/p>\n<p><strong>Missing Tooling and Access<\/strong><\/p>\n<p>Nothing kills momentum like spending your first two weeks waiting on credentials, VPN tokens, or access to source control systems.<\/p>\n<p>Result: Lost time, broken morale, and a first impression that the company isn\u2019t ready to support engineering excellence.<\/p>\n<p><strong>No Defined Milestones<\/strong><\/p>\n<p>When onboarding lacks goals\u2014like \u201cunderstand the job scheduler by week 2\u201d or \u201csubmit first safe code change by week 3\u201d\u2014engineers feel like they\u2019re wandering without purpose or validation.<\/p>\n<p>Result: Management loses visibility, and engineers lose confidence.<\/p>\n<p>Avoiding these pitfalls isn\u2019t just about empathy\u2014it\u2019s about systematizing success. And with modern AI tooling, companies can finally onboard engineers into legacy systems with clarity, context, and confidence.<\/p>\n<h4>The AI-Powered Knowledge Bridge<\/h4>\n<p>How to make legacy systems understandable on day one<\/p>\n<p>The biggest obstacle in onboarding engineers into legacy systems isn\u2019t the tech stack\u2014it\u2019s the lack of accessible, trustworthy knowledge. That\u2019s where AI becomes a game-changer.<\/p>\n<p>Instead of relying on senior developers to explain decades of logic manually, AI can autonomously extract and translate system knowledge into formats that are searchable, navigable, and actionable for new engineers.<\/p>\n<p><strong>What AI-Powered Documentation Enables<\/strong><\/p>\n<ul>\n<li>Natural Language Explanations: AI tools analyze legacy code (e.g., COBOL, RPG, FORTRAN) and generate human-readable summaries of modules, functions, and workflows.<\/li>\n<li>Interactive System Maps: Instead of hunting through tangled call stacks, engineers can visually explore dependencies, data flows, and subsystem boundaries.<\/li>\n<li>Real-Time Q&amp;A: Platforms like CodeAura\u2019s Elliot let engineers ask questions like \u201cWhat does this module do?\u201d or \u201cWhere is customer billing calculated?\u201d\u2014and get instant, context-aware answers.<\/li>\n<li>Progressive Learning Paths: AI can tailor explanations based on the engineer\u2019s role, familiarity, and current task\u2014shortening the time from lost to productive.<\/li>\n<\/ul>\n<p><strong>Why It Works<\/strong><\/p>\n<ul>\n<li>Scales Knowledge Transfer: One SME can help shape AI documentation that serves hundreds of future hires\u201424\/7.<\/li>\n<li>Reduces Risk: Developers get accurate explanations without poking around in production code.<\/li>\n<li>Improves Retention: Onboarding becomes smoother, less frustrating, and more empowering\u2014key for keeping talent in high-risk systems.<\/li>\n<\/ul>\n<p>AI bridges the gap between old systems and new minds. It doesn\u2019t just make legacy systems more transparent\u2014it makes new engineers more confident and productive from the start.<\/p>\n<h4>Designing a Sanity-Saving Onboarding Workflow<\/h4>\n<p>A phased approach to ramp-up without burnout<\/p>\n<p>The key to onboarding engineers into legacy systems isn\u2019t throwing them into the deep end\u2014it\u2019s building a structured, repeatable workflow that combines knowledge delivery, hands-on exploration, and AI-assisted support.<\/p>\n<p>Here\u2019s a practical, sanity-saving onboarding framework:<\/p>\n<p><strong>Week 1: Orientation + AI-Powered Immersion<\/strong><\/p>\n<ul>\n<li>Grant system access (read-only where appropriate)<\/li>\n<li>Walk through system architecture using interactive AI-generated diagrams<\/li>\n<li>Assign the engineer their own sandboxed AI instance (e.g., CodeAura\u2019s Elliot) to explore the codebase without risk<\/li>\n<li>Include structured \u201cmicro-missions\u201d like:\n<ul>\n<li>\u201cIdentify where user login is handled\u201d<\/li>\n<li>\u201cFind how tax rates are calculated\u201d<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>Goal: Build confidence through guided discovery, not rote lecture.<\/p>\n<p><strong>Week 2\u20133: Role-Aligned Deep Dive<\/strong><\/p>\n<ul>\n<li>Assign real (but low-risk) tickets tied to the new engineer\u2019s domain (e.g., frontend tweaks to a legacy reporting dashboard)<\/li>\n<li>Use AI-generated documentation to explain the code flow behind each task<\/li>\n<li>Pair with a mentor weekly\u2014but let the AI handle most day-to-day questions<\/li>\n<\/ul>\n<p>Goal: Begin contributing while learning in context.<\/p>\n<p><strong>Week 4+: Independent Contribution with Guardrails<\/strong><\/p>\n<ul>\n<li>Transition engineer to write their own safe code changes<\/li>\n<li>Enable AI-powered diff explainers to validate code impacts<\/li>\n<li>Hold weekly retros focused on what still feels confusing\u2014and use those insights to improve documentation<\/li>\n<\/ul>\n<p>Goal: Reach \u201cTime to Contribution\u201d within 30 days\u2014confident, not just active.<\/p>\n<p><strong>Feedback Loop for the Team<\/strong><\/p>\n<ul>\n<li>Let each new hire log knowledge gaps and AI blind spots<\/li>\n<li>Use this data to improve AI training models and onboarding flows<\/li>\n<li>Document onboarding metrics (time-to-commit, % of support tickets AI-resolved)<\/li>\n<\/ul>\n<p>Outcome: Onboarding that improves over time\u2014automated, scalable, and human-centered.<\/p>\n<p>This isn\u2019t just about survival\u2014it\u2019s about turning onboarding into a strategic advantage. Companies that follow this model see faster ramp-up, fewer errors, and higher long-term retention.<\/p>\n<h4>Measuring Success: Time to Contribution, Not Just Access<\/h4>\n<p>How to quantify onboarding ROI in legacy environments<\/p>\n<p>In modern systems, onboarding success is often measured by how quickly a developer pushes their first commit. But in legacy environments, that benchmark can be misleading. Gaining system access is easy\u2014understanding enough to contribute without breaking anything is what matters.<\/p>\n<p>That\u2019s why the most effective teams shift their focus from &#8220;time to access&#8221; to &#8220;time to contribution.&#8221; This is the point when a new engineer can:<\/p>\n<ul>\n<li>Safely make code changes with minimal supervision<\/li>\n<li>Troubleshoot issues using available knowledge resources<\/li>\n<li>Understand system dependencies and their impact<\/li>\n<li>Ask fewer tribal questions and rely more on institutionalized knowledge<\/li>\n<\/ul>\n<p>Key metrics to track include:<\/p>\n<ol>\n<li>Time to First Safe Code Change: How many days until the engineer submits a change that passes review and doesn\u2019t require major rework?<\/li>\n<li>Percentage of AI-Supported Tasks: What proportion of onboarding questions are answered through AI tools instead of manual SME intervention<\/li>\n<li>Onboarding Ticket Resolution Time: How long does it take for a new engineer to resolve onboarding-specific tickets (e.g., documentation fixes, small bugs, test scaffolding)?<\/li>\n<li>Mentorship Load Reduction: How much time do senior developers spend supporting new hires, and does that decline over the first 4\u20136 weeks?<\/li>\n<li>Retention Beyond 90 Days: Are engineers staying and growing, or leaving because the legacy complexity was too high?<\/li>\n<\/ol>\n<p>By tracking these indicators, engineering managers can justify the investment in onboarding infrastructure\u2014especially AI documentation tools\u2014as a measurable contributor to developer productivity and morale.<\/p>\n<p>When onboarding becomes predictable and performance-driven, legacy doesn\u2019t feel like a burden\u2014it becomes an environment that respects time, talent, and growth.<\/p>\n<h4>From Mind-Melting to Mission-Ready<\/h4>\n<p>Turning legacy onboarding into a repeatable, scalable advantage<\/p>\n<p>Legacy systems aren\u2019t going away anytime soon\u2014and neither is the need to onboard new engineers into them. But the old way of doing it\u2014relying on hallway knowledge, outdated PDFs, and overworked gatekeepers\u2014is no longer sustainable.<\/p>\n<p>The stakes are too high. These systems drive billions in revenue, enable critical services, and operate under intense regulatory scrutiny. Onboarding isn\u2019t just about filling seats\u2014it\u2019s about protecting operational continuity, reducing risk, and building resilient engineering teams.<\/p>\n<p>What was once a mind-melting process can now become a repeatable, scalable advantage. With AI-powered documentation, structured onboarding workflows, and outcome-focused metrics, companies can transform legacy code from a liability into a learning platform.<\/p>\n<p>New engineers don\u2019t have to fear legacy systems\u2014they can engage with them confidently. And engineering leaders don\u2019t have to dread the next resignation\u2014they can build onboarding processes that outlast individuals and scale with the team.<\/p>\n<p>Because in the end, onboarding isn\u2019t just a handoff\u2014it\u2019s a foundation. And when that foundation is solid, even a 40-year-old system can support the future.<\/p>\n<p><strong>Let\u2019s Talk About Your Mainframe Onboarding Needs<\/strong>&nbsp;\u2014 <a href=\"https:\/\/calendly.com\/suyash-codeaura\/30min\" target=\"_blank\" rel=\"noopener\">Schedule a session with CodeAura today<\/a>.<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t<\/div>","protected":false},"excerpt":{"rendered":"<p>Learn how to onboard developers into 40-year-old legacy systems using AI, structured workflows, and metrics that improve time to contribution and retention.<\/p>","protected":false},"author":1,"featured_media":14447,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_mo_disable_npp":"","footnotes":""},"categories":[61],"tags":[60],"class_list":["post-14438","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-general","tag-general","entry"],"rttpg_featured_image_url":{"full":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"landscape":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"portraits":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"thumbnail":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-150x150.jpg",150,150,true],"medium":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-300x200.jpg",300,200,true],"large":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-1024x683.jpg",1024,683,true],"1536x1536":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"2048x2048":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"trp-custom-language-flag":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-18x12.jpg",18,12,true],"post-thumbnail":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind.jpg",1200,800,false],"martex-360x234-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-360x234.jpg",360,234,true],"martex-390x300-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-390x300.jpg",390,300,true],"martex-400x400-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-400x400.jpg",400,400,true],"martex-450x350-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-450x350.jpg",450,350,true],"martex-750x320-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-750x320.jpg",750,320,true],"martex-700x500-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-700x500.jpg",700,500,true],"martex-1000x600-cropped":["https:\/\/codeaura.ai\/wp-content\/uploads\/2025\/06\/How-to-Onboard-New-Engineers-Into-40-Year-Old-Systems-Without-Losing-Your-Mind-1000x600.jpg",1000,600,true]},"rttpg_author":{"display_name":"suyash@codevigor.com","author_link":"https:\/\/codeaura.ai\/fr\/author\/suyashcodevigor-com\/"},"rttpg_comment":0,"rttpg_category":"<a href=\"https:\/\/codeaura.ai\/fr\/category\/general\/\" rel=\"category tag\">General<\/a>","rttpg_excerpt":"Learn how to onboard developers into 40-year-old legacy systems using AI, structured workflows, and metrics that improve time to contribution and retention.","_links":{"self":[{"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/posts\/14438","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/comments?post=14438"}],"version-history":[{"count":14,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/posts\/14438\/revisions"}],"predecessor-version":[{"id":14458,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/posts\/14438\/revisions\/14458"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/media\/14447"}],"wp:attachment":[{"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/media?parent=14438"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/categories?post=14438"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codeaura.ai\/fr\/wp-json\/wp\/v2\/tags?post=14438"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}