{"id":948,"date":"2026-02-25T10:32:37","date_gmt":"2026-02-25T10:32:37","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/"},"modified":"2026-02-25T10:32:37","modified_gmt":"2026-02-25T10:32:37","slug":"crc-in-agile-development-integrating-design-into-sprints","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/","title":{"rendered":"Integrating CRC Design into Agile Sprints"},"content":{"rendered":"<p>Many teams assume that agile means skipping formal design\u2014focusing only on coding and user stories. But that\u2019s a misconception. The real power of agile lies in its ability to integrate lightweight, collaborative design practices like CRC modeling directly into sprint cycles. CRC cards aren\u2019t just for brainstorming; they are a living design artifact that informs sprint planning, refines backlog items, and grounds technical decisions in shared understanding. When done right, CRC in agile development becomes a bridge between business needs and technical implementation\u2014keeping teams aligned and architecture sound.<\/p>\n<p>I\u2019ve worked with dozens of teams across startups and enterprise systems, and the most successful ones don\u2019t wait for full UML diagrams. Instead, they use CRC cards during refinement sessions to explore domain behavior, identify key actors, and define responsibilities\u2014before writing a single line of code. This isn\u2019t theory. It\u2019s a practice I\u2019ve refined over two decades: CRC design sprint sessions aren\u2019t just about sketching\u2014they\u2019re about building consensus, validating assumptions, and making design visible early.<\/p>\n<p>By the end of this chapter, you\u2019ll understand how to use CRC modeling as a core part of your agile workflow, transform user stories into actionable domain models, and ensure your sprints are not just about delivery\u2014but about intelligent, sustainable design.<\/p>\n<h2>Why CRC Belongs in Agile Sprints<\/h2>\n<p>Agile isn\u2019t about abandoning design\u2014it\u2019s about making it adaptive, collaborative, and just-in-time. CRC cards are the perfect tool for this. They\u2019re lightweight, easy to modify, and encourage team discussion.<\/p>\n<p>Unlike formal UML diagrams that can feel static or intimidating, CRC cards are meant to be moved, erased, and rethought. This makes them ideal for agile refinement sessions where the goal is not perfection, but clarity.<\/p>\n<p>Here\u2019s how CRC integrates naturally into the agile lifecycle:<\/p>\n<ul>\n<li><strong>Sprint Planning:<\/strong> Use CRC cards to break down complex epics into domain-level components.<\/li>\n<li><strong>Backlog Refinement:<\/strong> Turn vague user stories into responsibilities and collaborations.<\/li>\n<li><strong>Design Review:<\/strong> Revisit CRC models after implementation to validate alignment.<\/li>\n<li><strong>Onboarding:<\/strong> New developers can understand the system by walking through CRC cards.<\/li>\n<\/ul>\n<h3>How CRC Models Inform User Story Refinement<\/h3>\n<p>Consider a story like: \u201cAs a customer, I want to track my order status so I can plan my delivery.\u201d This is functional, but it lacks depth. CRC modeling brings it alive.<\/p>\n<p>During refinement, the team identifies:<\/p>\n<ul>\n<li><strong>Class:<\/strong> <code>Order<\/code><\/li>\n<li><strong>Responsibility:<\/strong> \u201cStore order status,\u201d \u201cNotify customer of updates\u201d<\/li>\n<li><strong>Collaboration:<\/strong> \u201cWith <code>Customer<\/code>,\u201d \u201cTo <code>DeliveryService<\/code>\u201d<\/li>\n<\/ul>\n<p>Now the story isn\u2019t just about tracking\u2014there\u2019s a clear model. This is where agile UML workflow begins: not with a diagram, but with shared understanding.<\/p>\n<h2>Step-by-Step: Running a CRC Design Sprint<\/h2>\n<p>Running a CRC design sprint isn\u2019t about perfection. It\u2019s about speed, clarity, and team ownership. Here\u2019s a practical workflow I\u2019ve used with teams from fintech to healthcare applications.<\/p>\n<ol>\n<li><strong>Start with a user story.<\/strong> Choose one from the backlog that\u2019s ambiguous or complex.<\/li>\n<li><strong>Identify classes.<\/strong> Ask: \u201cWhat objects are central to this story?\u201d Write them on cards.<\/li>\n<li><strong>Assign responsibilities.<\/strong> For each class, ask: \u201cWhat should it do?\u201d Be specific\u2014avoid vague terms like \u201cmanage\u201d or \u201chandle.\u201d<\/li>\n<li><strong>Map collaborations.<\/strong> Identify which classes interact with others. Use lines or arrows to show relationships.<\/li>\n<li><strong>Review for completeness.<\/strong> Are all key behaviors captured? Is there a missing entity?<\/li>\n<li><strong>Translate to UML (optional).<\/strong> If needed, sketch a quick class diagram based on the CRC model.<\/li>\n<\/ol>\n<p>Each step takes 5\u201310 minutes. A full session lasts 30\u201345 minutes. The goal isn\u2019t documentation\u2014it\u2019s consensus.<\/p>\n<h3>Example: Order Tracking in a Retail App<\/h3>\n<table>\n<tbody>\n<tr>\n<th>Class<\/th>\n<th>Responsibility<\/th>\n<th>Collaboration<\/th>\n<\/tr>\n<tr>\n<td><code>Order<\/code><\/td>\n<td>Store status (pending, shipped, delivered)<\/td>\n<td>With <code>Customer<\/code>, notifies <code>NotificationService<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>Customer<\/code><\/td>\n<td>View order history, receive status updates<\/td>\n<td>Receives from <code>Order<\/code>, uses <code>DeliveryService<\/code> API<\/td>\n<\/tr>\n<tr>\n<td><code>DeliveryService<\/code><\/td>\n<td>Provide tracking info, update delivery status<\/td>\n<td>Called by <code>Order<\/code>, returns to <code>Customer<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This table is born from a 15-minute CRC sprint. It\u2019s not a formal model yet\u2014but it\u2019s enough to guide implementation.<\/p>\n<h2>Linking CRC to Iterative Modeling<\/h2>\n<p>Agile thrives on iteration. But too many teams treat iteration as just coding cycles\u2014missing the opportunity to refine the model. That\u2019s where iterative modeling comes in.<\/p>\n<p>After each sprint, revisit the CRC cards. Ask:<\/p>\n<ul>\n<li>Did the implementation match our original responsibilities?<\/li>\n<li>Did we miss any behavior?<\/li>\n<li>Are any collaborations now redundant or unclear?<\/li>\n<\/ul>\n<p>This feedback loop is crucial. It turns a one-time sketch into a living design artifact. I\u2019ve seen teams use this to refactor legacy code with remarkable clarity\u2014because every change is tied to a shared understanding.<\/p>\n<p>Here\u2019s how iterative modeling benefits your sprint cycle:<\/p>\n<ul>\n<li><strong>Refines future user stories:<\/strong> As you learn from implementation, new stories emerge more clearly.<\/li>\n<li><strong>Reduces rework:<\/strong> Misunderstandings caught in refinement are far cheaper than bugs in production.<\/li>\n<li><strong>Balances speed and quality:<\/strong> You don\u2019t need full UML up front\u2014just enough design to proceed safely.<\/li>\n<\/ul>\n<h3>When to Advance from CRC to UML<\/h3>\n<p>There\u2019s no rule that says you must convert every CRC card to a UML diagram. But when the model stabilizes\u2014after 2\u20133 sprints\u2014it\u2019s time to formalize.<\/p>\n<p>Use this checklist to decide:<\/p>\n<ul>\n<li>Do multiple team members understand the model without explanation?<\/li>\n<li>Are responsibilities consistent across stories?<\/li>\n<li>Are collaborations well-defined and stable?<\/li>\n<li>Is the system being extended in predictable ways?<\/li>\n<\/ul>\n<p>If yes, it\u2019s time to map CRC elements to class diagrams. Remember: UML doesn\u2019t replace CRC\u2014it inherits from it.<\/p>\n<h2>Common Pitfalls and How to Avoid Them<\/h2>\n<p>Even with good intent, teams stumble. Here are the most common mistakes in integrating CRC design into agile sprints\u2014and how to fix them.<\/p>\n<h3>1. Treating CRC as a One-Time Exercise<\/h3>\n<p>Some teams run a CRC session once and never touch it again. That breaks the feedback loop.<\/p>\n<p><strong>Solution:<\/strong> Revisit CRC models at the end of each sprint. Update them based on new behavior or refactored code.<\/p>\n<h3>2. Over-Engineering During Refinement<\/h3>\n<p>Teams sometimes dive into method signatures, parameters, and visibility too early.<\/p>\n<p><strong>Solution:<\/strong> Focus only on behavior and collaboration. Save details for when the model is stable.<\/p>\n<h3>3. Ignoring the Business Context<\/h3>\n<p>CRC cards can become purely technical\u2014losing touch with user needs.<\/p>\n<p><strong>Solution:<\/strong> Always tie responsibilities back to user stories. Ask: \u201cDoes this help the customer?\u201d<\/p>\n<h3>4. Skipping the Team Conversation<\/h3>\n<p>Working in isolation may produce a diagram\u2014but not shared understanding.<\/p>\n<p><strong>Solution:<\/strong> Use sticky notes, whiteboards, and pair work. CRC is a team exercise, not a solo task.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How does CRC design sprint help in backlog refinement?<\/h3>\n<p>CRC design sprint transforms vague user stories into concrete domain models. By identifying classes, responsibilities, and collaborations, teams uncover hidden complexity and clarify acceptance criteria\u2014making stories more testable and implementable.<\/p>\n<h3>Can CRC in agile development replace UML diagrams?<\/h3>\n<p>No\u2014CRC isn\u2019t a replacement. It\u2019s a precursor. CRC helps discover and validate design early. UML diagrams provide a formal, persistent record. Use CRC to explore, UML to document.<\/p>\n<h3>What\u2019s the difference between agile UML workflow and traditional modeling?<\/h3>\n<p>Traditional modeling often starts with full UML diagrams. Agile UML workflow starts with CRC cards and evolves iteratively. It\u2019s responsive to change, avoids over-documentation, and prioritizes team understanding over notation.<\/p>\n<h3>When should I stop using CRC cards and start drawing UML class diagrams?<\/h3>\n<p>When the model has stabilized\u2014after 2\u20133 iterations of refinement. Use CRC for exploration; move to UML when you have consistent, repeatable behavior and responsibilities.<\/p>\n<h3>How can I keep CRC design sprint sessions productive?<\/h3>\n<p>Set a timebox (20\u201345 minutes), limit participants to 4\u20136 people, use sticky notes, and rotate roles (facilitator, recorder, timekeeper). Focus on behavior, not syntax.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Many teams assume that agile means skipping formal design\u2014focusing only on coding and user stories. But that\u2019s a misconception. The real power of agile lies in its ability to integrate lightweight, collaborative design practices like CRC modeling directly into sprint cycles. CRC cards aren\u2019t just for brainstorming; they are a living design artifact that informs [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":945,"menu_order":2,"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-948","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>CRC in Agile Development: Integrating Design into Sprints<\/title>\n<meta name=\"description\" content=\"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.\" \/>\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\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/\" \/>\n<meta property=\"og:locale\" content=\"ru_RU\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"CRC in Agile Development: Integrating Design into Sprints\" \/>\n<meta property=\"og:description\" content=\"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u041f\u0440\u0438\u043c\u0435\u0440\u043d\u043e\u0435 \u0432\u0440\u0435\u043c\u044f \u0434\u043b\u044f \u0447\u0442\u0435\u043d\u0438\u044f\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 \u043c\u0438\u043d\u0443\u0442\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/\",\"name\":\"CRC in Agile Development: Integrating Design into Sprints\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#website\"},\"datePublished\":\"2026-02-25T10:32:37+00:00\",\"description\":\"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/#breadcrumb\"},\"inLanguage\":\"ru-RU\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/ru\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"From CRC Cards to Class Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Practical Application Scenarios\",\"item\":\"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Integrating CRC Design into Agile Sprints\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/ru\/\",\"name\":\"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/ru\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"ru-RU\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#organization\",\"name\":\"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439\",\"url\":\"https:\/\/skills.visual-paradigm.com\/ru\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"ru-RU\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/ru\/wp-content\/uploads\/sites\/10\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/ru\/wp-content\/uploads\/sites\/10\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/ru\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"CRC in Agile Development: Integrating Design into Sprints","description":"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.","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\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/","og_locale":"ru_RU","og_type":"article","og_title":"CRC in Agile Development: Integrating Design into Sprints","og_description":"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.","og_url":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/","og_site_name":"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439","twitter_card":"summary_large_image","twitter_misc":{"\u041f\u0440\u0438\u043c\u0435\u0440\u043d\u043e\u0435 \u0432\u0440\u0435\u043c\u044f \u0434\u043b\u044f \u0447\u0442\u0435\u043d\u0438\u044f":"6 \u043c\u0438\u043d\u0443\u0442"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/","url":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/","name":"CRC in Agile Development: Integrating Design into Sprints","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/ru\/#website"},"datePublished":"2026-02-25T10:32:37+00:00","description":"Learn how CRC design in agile development streamlines sprint planning, links user stories to domain models, and enables iterative modeling for robust software architecture.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/#breadcrumb"},"inLanguage":"ru-RU","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/crc-in-agile-development-integrating-design-into-sprints\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/ru\/"},{"@type":"ListItem","position":2,"name":"From CRC Cards to Class Diagrams","item":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/"},{"@type":"ListItem","position":3,"name":"Practical Application Scenarios","item":"https:\/\/skills.visual-paradigm.com\/ru\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-case-study\/"},{"@type":"ListItem","position":4,"name":"Integrating CRC Design into Agile Sprints"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/ru\/#website","url":"https:\/\/skills.visual-paradigm.com\/ru\/","name":"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/ru\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/ru\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"ru-RU"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/ru\/#organization","name":"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439","url":"https:\/\/skills.visual-paradigm.com\/ru\/","logo":{"@type":"ImageObject","inLanguage":"ru-RU","@id":"https:\/\/skills.visual-paradigm.com\/ru\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/ru\/wp-content\/uploads\/sites\/10\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/ru\/wp-content\/uploads\/sites\/10\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills \u0420\u0443\u0441\u0441\u043a\u0438\u0439"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/ru\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/docs\/948","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/docs\/948\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/docs\/945"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/media?parent=948"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/ru\/wp-json\/wp\/v2\/doc_tag?post=948"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}