{"id":944,"date":"2026-02-25T10:32:35","date_gmt":"2026-02-25T10:32:35","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/"},"modified":"2026-02-25T10:32:35","modified_gmt":"2026-02-25T10:32:35","slug":"crc-uml-refactoring-feedback-cycles","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/","title":{"rendered":"Refactoring Through CRC Feedback Cycles"},"content":{"rendered":"

About 6 out of 10 teams I’ve worked with assume that once a class diagram is drawn, the design is locked in. That\u2019s a mistake. The real power of CRC modeling lies not in the first draft\u2014but in how it evolves through CRC iteration<\/strong> and structured feedback. When teams treat CRC cards as living documents rather than static inputs, the resulting UML models become more accurate, cohesive, and aligned with actual system behavior.<\/p>\n

I\u2019ve seen teams spend weeks refining a class diagram only to discover it doesn\u2019t reflect user stories or domain interactions. The fix isn\u2019t in adding more complexity\u2014it\u2019s in re-engaging the CRC process. Each round of feedback, especially from cross-functional team members, reveals gaps in responsibility mapping, incomplete collaborations, or ambiguous associations.<\/p>\n

This chapter shows how to use UML improvement cycle<\/strong> feedback loops to turn early, informal CRC sketches into robust, maintainable class diagrams. You\u2019ll learn how to apply responsibility revision<\/strong> not as a cleanup step, but as a core design activity that strengthens the entire model.<\/p>\n

Why Feedback Cycles Are the Heart of Model Evolution<\/h2>\n

UML diagrams aren\u2019t static blueprints. They\u2019re living models that reflect team understanding. Without feedback, they become artifacts of individual assumptions, not shared knowledge.<\/p>\n

When CRC sessions are followed by open reviews, diverse perspectives surface missing responsibilities, conflicting assumptions, or duplicated classes. That\u2019s not a flaw\u2014it\u2019s a feature.<\/p>\n

The key is to treat every feedback round as a CRC iteration<\/strong>, where the team revisits the cards, re-evaluates responsibilities, and then updates the UML diagram accordingly. This isn\u2019t rework\u2014it\u2019s refinement.<\/p>\n

How Feedback Translates into Model Improvement<\/h3>\n

Feedback isn\u2019t just about fixing errors. It\u2019s about deepening understanding. A developer might question why a PaymentProcessor<\/code> class has a sendReceipt()<\/code> method. The CRC team may realize that receipt handling is better managed by a NotificationService<\/code>.<\/p>\n

That insight triggers a responsibility revision<\/strong>. The class diagram is updated: PaymentProcessor<\/code> now depends on NotificationService<\/code>, and the association is properly labeled.<\/p>\n

This pattern\u2014identify \u2192 challenge \u2192 revise \u2192 reflect\u2014forms the UML improvement cycle<\/strong>. Each iteration tightens the model\u2019s alignment with real-world behavior, not just syntax.<\/p>\n

Implementing the CRC Feedback Loop<\/h2>\n

Design isn\u2019t linear. It\u2019s recursive. The most effective teams use structured feedback loops that mirror agile inspection cycles, but at the model level.<\/p>\n

Step-by-Step Feedback Cycle<\/h3>\n
    \n
  1. \n

    Conduct a CRC session to explore a system area (e.g., order processing).<\/p>\n<\/li>\n

  2. \n

    Map findings into a preliminary UML class diagram.<\/p>\n<\/li>\n

  3. \n

    Host a 30-minute design review with developers, testers, and domain experts.<\/p>\n<\/li>\n

  4. \n

    Collect feedback on: missing responsibilities, unclear associations, or duplicated roles.<\/p>\n<\/li>\n

  5. \n

    Revise CRC cards with new insights\u2014this is a CRC iteration<\/strong>.<\/p>\n<\/li>\n

  6. \n

    Update the UML diagram based on revised responsibilities.<\/p>\n<\/li>\n

  7. \n

    Repeat until consensus and consistency are achieved.<\/p>\n<\/li>\n<\/ol>\n

    Each cycle tightens the design. The diagram becomes more than a document\u2014it becomes a shared source of truth.<\/p>\n

    What to Look for in Feedback<\/h3>\n

    Not all feedback is equally valuable. Focus on input that challenges assumptions or reveals behavioral gaps. Examples:<\/p>\n

      \n
    • \u201cWhy does Customer<\/code> manage Order<\/code> history? Shouldn\u2019t that be handled by a HistoryService<\/code>?\u201d<\/li>\n
    • \u201cThe InventoryManager<\/code> seems to need StockLevel<\/code> data. Is that an attribute or a separate class?\u201d<\/li>\n
    • \u201cI don\u2019t see a link between Payment<\/code> and Order<\/code>. How\u2019s payment confirmed?\u201d<\/li>\n<\/ul>\n

      These questions aren\u2019t bugs\u2014they\u2019re design signals. They point to missing responsibilities or misunderstood collaborations.<\/p>\n

      Common Pitfalls in Feedback Integration<\/h2>\n

      Even with good intentions, teams can misstep. Here\u2019s how to avoid common traps:<\/p>\n

      1. Over-Engineering During Feedback<\/h3>\n

      Feedback often brings up \u201cwhat if\u201d scenarios. A tester might suggest adding a ValidationRule<\/code> class or a PaymentStatus<\/code> enum. Push back if it\u2019s speculative. Ask: \u201cDoes this belong to the current scope?\u201d If not, log it as a future enhancement, not a design requirement.<\/p>\n

      Keep the model focused. Use responsibility revision<\/strong> only to fix what\u2019s already implied\u2014not to add every possible variation.<\/p>\n

      2. Ignoring Behavioral Intent<\/h3>\n

      One team added a LogService<\/code> class to every class with a \u201cprocess\u201d responsibility. The model became bloated and hard to navigate.<\/p>\n

      Instead, ask: \u201cWhat behavior is actually being modeled?\u201d If logging is a side effect, use a flag or a simple method. If it\u2019s a core concern, then consider a separate class\u2014but only if it\u2019s invoked across multiple scenarios.<\/p>\n

      3. Repeating the Same Feedback<\/h3>\n

      If the same question arises in multiple reviews, the CRC cards are likely unclear. Revisit the responsibility wording. Use active verbs: \u201cnotify user,\u201d \u201ccalculate total,\u201d \u201cvalidate payment.\u201d Avoid vague terms like \u201chandle\u201d or \u201cprocess.\u201d<\/p>\n

      Clarity in CRC cards reduces ambiguity in UML models.<\/p>\n

      When to Stop the Loop<\/h2>\n

      There\u2019s no magic number of iterations. But you can tell it\u2019s time to stop when:<\/p>\n

        \n
      • Feedback is focused on minor refinements (e.g., naming, visibility).<\/li>\n
      • Team consensus is stable across multiple reviews.<\/li>\n
      • All key domain scenarios are modeled and validated.<\/li>\n<\/ul>\n

        At that point, the model is ready for documentation, code generation, or integration into the development workflow.<\/p>\n

        Tools to Support Iterative Refactoring<\/h2>\n

        Modern modeling tools like Visual Paradigm<\/strong> simplify the CRC UML refactoring<\/strong> workflow. You can:<\/p>\n

          \n
        • Link CRC cards directly to UML classes for traceability.<\/li>\n
        • Use version control to track changes across feedback cycles.<\/li>\n
        • Automatically generate class diagrams from updated CRC data.<\/li>\n<\/ul>\n

          These features turn the feedback loop into a collaborative, auditable process\u2014not a series of disjointed edits.<\/p>\n

          Real-World Example: Order Processing Refactoring<\/h2>\n

          Consider a team modeling an e-commerce order system. Their first UML diagram had:<\/p>\n

            \n
          • Order<\/code> with calculateTotal()<\/code><\/li>\n
          • Order<\/code> with sendConfirmation()<\/code><\/li>\n
          • Order<\/code> with updateInventory()<\/code><\/li>\n<\/ul>\n

            During a review, a developer asked: \u201cWho manages inventory changes? Shouldn\u2019t that be in a separate service?\u201d<\/p>\n

            This triggered a CRC iteration<\/strong>. The team revised the cards:<\/p>\n

              \n
            • Order<\/code> holds calculateTotal()<\/code> and notifyCustomer()<\/code><\/li>\n
            • InventoryService<\/code> handles updateStock()<\/code><\/li>\n
            • Order<\/code> depends on InventoryService<\/code><\/li>\n<\/ul>\n

              The updated UML diagram now reflects a clearer separation of concerns. The responsibility revision<\/strong> improved cohesion and reduced coupling.<\/p>\n

              Frequently Asked Questions<\/h2>\n

              How many CRC iterations should I run before finalizing the UML model?<\/h3>\n

              There\u2019s no fixed number. I\u2019ve seen teams complete the process in 2\u20133 rounds. If your feedback cycle yields only minor edits (naming, visibility, minor association tweaks), you\u2019re ready to move on.<\/p>\n

              Can I use CRC cards in a sprint review or planning meeting?<\/h3>\n

              Absolutely. CRC cards are ideal for planning because they\u2019re quick to sketch and easy to discuss. Use them in backlog refinement to explore domain complexity before writing user stories or designing classes.<\/p>\n

              What if team members disagree on responsibility assignment?<\/h3>\n

              Disagreement is healthy. Use it as a signal to re-express responsibilities in behavioral terms. Ask: \u201cWhat happens when X occurs?\u201d That often reveals the correct actor and responsibility.<\/p>\n

              Does CRC UML refactoring slow down development?<\/h3>\n

              Not if done right. The upfront effort reduces rework later. A well-refined model leads to cleaner code, fewer bugs, and faster onboarding.<\/p>\n

              Is it okay to skip CRC cards and go straight to UML?<\/h3>\n

              No. CRC cards help teams explore intent before committing to structure. Skipping them often leads to over-abstracted, rigid models that don’t reflect real behavior.<\/p>\n

              How do I ensure feedback is constructive and not just criticism?<\/h3>\n

              Frame feedback around behavior, not people. Instead of \u201cThis is wrong,\u201d try \u201cI noticed this method might be called from multiple places\u2014could it be a better fit in a separate service?\u201d<\/p>\n","protected":false},"excerpt":{"rendered":"

              About 6 out of 10 teams I’ve worked with assume that once a class diagram is drawn, the design is locked in. That\u2019s a mistake. The real power of CRC modeling lies not in the first draft\u2014but in how it evolves through CRC iteration and structured feedback. When teams treat CRC cards as living documents […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":940,"menu_order":3,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-944","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"\nCRC UML Refactoring: Evolve Your Design Through Feedback<\/title>\n<meta name=\"description\" content=\"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"CRC UML Refactoring: Evolve Your Design Through Feedback\" \/>\n<meta property=\"og:description\" content=\"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Deutsch\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data1\" content=\"6\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/\",\"name\":\"CRC UML Refactoring: Evolve Your Design Through Feedback\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#website\"},\"datePublished\":\"2026-02-25T10:32:35+00:00\",\"description\":\"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"From CRC Cards to Class Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Refining and Validating the Design\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Refactoring Through CRC Feedback Cycles\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/\",\"name\":\"Visual Paradigm Skills Deutsch\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/de\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#organization\",\"name\":\"Visual Paradigm Skills Deutsch\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Deutsch\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"CRC UML Refactoring: Evolve Your Design Through Feedback","description":"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.","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:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/","og_locale":"de_DE","og_type":"article","og_title":"CRC UML Refactoring: Evolve Your Design Through Feedback","og_description":"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.","og_url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/","og_site_name":"Visual Paradigm Skills Deutsch","twitter_card":"summary_large_image","twitter_misc":{"Gesch\u00e4tzte Lesezeit":"6\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/","url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/","name":"CRC UML Refactoring: Evolve Your Design Through Feedback","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#website"},"datePublished":"2026-02-25T10:32:35+00:00","description":"Master the CRC UML refactoring process with iterative feedback cycles. Learn how CRC iteration refines UML design, ensuring robust, maintainable models through responsibility revision and continuous improvement.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/crc-uml-refactoring-feedback-cycles\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/de\/"},{"@type":"ListItem","position":2,"name":"From CRC Cards to Class Diagrams","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/"},{"@type":"ListItem","position":3,"name":"Refining and Validating the Design","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/crc-cards-to-class-diagrams\/refining-and-validating-the-design\/"},{"@type":"ListItem","position":4,"name":"Refactoring Through CRC Feedback Cycles"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/de\/#website","url":"https:\/\/skills.visual-paradigm.com\/de\/","name":"Visual Paradigm Skills Deutsch","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/de\/#organization","name":"Visual Paradigm Skills Deutsch","url":"https:\/\/skills.visual-paradigm.com\/de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Deutsch"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/944","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/944\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/940"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/media?parent=944"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/doc_tag?post=944"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}