The Anatomy of a Healthy Design Team

The Nervous System: People & Psychology

• Career conversations and growth planning
• Team psychological safety and dynamics
• Workload management and resource allocation
• Performance reviews and feedback systems
• Creating learning opportunities

• Providing craft-specific feedback on team member development
• Identifying design skill gaps and growth opportunities
• Offering design mentorship and guidance
• Signaling when team members are ready for more complex challenges

The Muscular System: Craft & Execution

• Definition of design standards and system usage
• Feedback on what design work meets the standard
• Experience direction for the product
• Design decisions and product-wide alignment
• Innovation and craft advancement

• Ensuring design standards are understood and adopted across the team
• Confirming experience direction is being followed
• Supporting practices and systems that scale without bottlenecking
• Facilitating design alignment across teams
• Providing resources and removing obstacles to great craft work

The Circulatory System: Strategy & Flow

• User needs are met by the product
• Overall product quality and experience
• Strategic design initiatives
• Research-based user needs for each initiative

• Communication to team and stakeholders
• Stakeholder management and alignment
• Cross-functional team accountability
• Strategic business initiatives

• Co-creation of strategy with leadership
• Team goals and prioritization approach
• Organizational structure decisions
• Success measures and frameworks

Keeping the Organism Healthy

Be Explicit About Which System You’re Tending

Create Healthy Feedback Loops

Handle Handoffs Gracefully

Stay Curious, Not Territorial

When the Organism Gets Sick

System Isolation

Poor Circulation

Autoimmune Response

The Payoff

The Bottom Line

• Show you how to build a complete RAG pipeline using MongoDB Atlas and Cohere APIs
  
• Focus on data flow, retrieval, and generation
  
• Enable you to enhance answer quality through reranking to improve relevance and accuracy
  
• Enable detailed, flexible deployment with Docker Compose for local or cloud environments
  
• Explain MongoDB’s dual role as a vector store and chat memory for a seamless RAG application
  

Reasons to choose MongoDB and Cohere for RAG

• MongoDB Atlas and Cohere Command R+ facilitate the development of scalable, high-performing, and grounded AI applications.
  
• MongoDB Atlas provides a scalable, flexible, reliable, and fast database for managing large datasets used to ground generative models.
  
• Cohere Command R+ offers a sophisticated large language model (LLM) for natural language understanding and generation, incorporating retrieved data for factual accuracy and rapid inference.
  
• The combined use of MongoDB Atlas and Cohere Command R+ results in applications with fast and accurate responses, scalable architectures, and outputs informed by real-world data.
  

Architecture overview

• The initial step involves loading your source documents, which can be in various formats.
  
• These documents are then intelligently segmented into smaller, semantically meaningful chunks to optimize retrieval and processing.
  
• Cohere’s powerful embedding models generate dense vector representations of these text chunks, capturing their underlying meaning and semantic relationships.
  

• MongoDB Atlas, a fully managed and scalable database service, serves as the central repository for both the original text chunks and their corresponding vector embeddings.
  
• MongoDB Atlas’s built-in vector search capabilities (with MongoDB Atlas Vector Search) enable efficient and high-performance similarity searches based on the generated embeddings.
  
• This enables the scalable storage and retrieval of vast amounts of textual data and their corresponding vector representations.
  

• When a user poses a query, it undergoes a similar embedding process, using Cohere to generate a vector representation of the search intent.
  
• MongoDB Atlas then uses this query vector to perform a semantic search within its vector index.
  
• MongoDB Atlas efficiently identifies the most relevant document chunks based on their vector similarity to the query vector, surpassing simple keyword matching to comprehend the underlying meaning.
  

• To further refine the relevance of the retrieved document chunks, you can employ Cohere’s reranking models.
  
• The reranker analyzes the initially retrieved chunks in the context of the original query, scoring and ordering them based on a more nuanced understanding of their relevance.
  
• This step ensures that you’re prioritizing the most pertinent information for the final answer generation.
  

• The architecture then passes the top-ranked document chunks to Cohere’s Command R+ LLM.
  
• Command R+ uses its extensive knowledge and understanding of language to generate a grounded and coherent answer to the user’s query, with direct support from the information extracted from the retrieved documents.
  
• This ensures that the answers are accurate, contextually relevant, and traceable to the source material.
  

• To enable more natural and conversational interactions, you can store the history of the conversation in MongoDB.
  
• This enables the RAG application to maintain context across multiple turns, referencing previous queries and responses to provide more informed and relevant answers.
  
• By incorporating conversation history, the application gains memory and can engage in more meaningful dialogues with users.
  

Application Setup

• A MongoDB Atlas cluster (free tier is fine)
  
• A Cohere account and API key
  
• Python 3.8+
  
• Docker and Docker Compose
  
• A configured AWS CLI
  

Deployment steps

git clone https://github.com/mongodb-partners/maap-cohere-qs.git
cd maap-cohere-qs

• AWS Auth: Specify the AWS_REGION, AWS_ACCESS_KEY_ID, and AWS_SECRET_ACCESS_KEY for deployment.
  
• EC2 Instance Types: Choose suitable instance types for your workload.
  
• Network Configuration: Update key names, subnet IDs, security group IDs, etc.
  
• Authentication Keys: Fetch Project ID and API public and private keys for MongoDB Atlas cluster setup. Update the script file with the keys for APIPUBLICKEY, APIPRIVATEKEY, and GROUPID suitably.
  

chmod +x one-click.ksh
./one-click.ksh

Core workflow

model = "embed-english-v3.0"
response = self.co.embed(
            texts=[text],
            model=model,
            input_type=input_type, 
            embedding_types=['float']
)

• Create a vector search index on top of your collection:

index_models = [
    {
        "database": "asset_management_use_case",
        "collection": "market_reports",
        "index_model": SearchIndexModel(
            definition={
                "fields": [
                    {
                        "type": "vector",
                        "path": "embedding",
                        "numDimensions": 1024,
                        "similarity": "cosine"
                    },
                    {
                        "type": "filter",
                        "path": "key_metrics.p_e_ratio"
                    },
                    {
                        "type": "filter",
                        "path": "key_metrics.market_cap"
                    },
                    {
                        "type": "filter",
                        "path": "key_metrics.dividend_yield"
                    },
                    {
                        "type": "filter",
                        "path": "key_metrics.current_stock_price"
                    }
                ]
            },
            name="vector_index",
            type="vectorSearch",
        ),
    }
]

• A vector index in MongoDB enables fast, cosine-similarity-based lookups. MongoDB Atlas returns the top-k semantically similar documents, on top of which you can apply additional post filters to get more fine-grained results set in a bounded space.

response = self.co.rerank(
    query=query,
    documents=rerank_docs,
    top_n=top_n,
    model="rerank-english-v3.0",
    rank_fields=["company", "combined_attributes"]
)

The importance of reranking

The ability to combine everything

Conclusion

The challenge: Equipping store associates in an omnichannel world

1. Siloed systems

2. Absence of real-time inventory

The solution: A unified data platform for store associate empowerment

Key capabilities empowering store associates

• Intuitive search: Quickly locate products with full-text search (e.g., “The Duke and I book”), semantic search where context is crucial (e.g., “A romantic book saga for a teenager”), or hybrid search, which blends traditional keyword matching with semantic understanding for smarter results. AI-powered recommendations further enhance the personal shopper experience by suggesting similar or complementary products.
  
• Access to real-time inventory: Instantly check stock availability in the current and nearby stores by connecting to existing inventory systems and real-time updates. An associate could say, “We’re out of stock, but the X location has 10 units.”
  
• Seamless order management and cross-channel fulfillment: Enable follow-up actions like, “The X store has 10 units. Would you like me to place an order for home delivery or in-store pickup?”
  
• Access to customer context: With permissioned access, enable associates to view relevant customer details, including previous purchases or saved products, to provide personalized assistance.
  

The technology foundation: Why MongoDB Atlas?

• Scalability and a flexible document model: MongoDB Atlas supports complex data types, including vector embeddings, documents, graphs, and time series. This is ideal for diverse and evolving datasets like catalogs, customer profiles, inventory, and transactions.
  
• Real-time data: Atlas enables seamless, real-time responses to operational data changes through Change Streams and Atlas Triggers. These capabilities make it easy to integrate with systems like shipping or inventory management, ensuring timely updates to the unified view.
  
• Built-in search capabilities: Atlas provides native support of full-text Search ($search) and vector search ($vectorSearch) (through MongoDB Atlas Vector Search), which reduces complexity and simplifies the architecture by eliminating the need for third-party tools.
  
• Robust enterprise security and data privacy: MongoDB Atlas provides the strong security required for giving store associates access to a unified view of sensitive data. MongoDB meets privacy regulations and offers built-in features like authentication, authorization, and full-lifecycle data encryption (at rest, in transit, and in use).
  
• Consolidated operational data: Atlas acts as the core data layer, integrating information from systems like points of sale, e-commerce, and customer relationship management into a unified platform.
  

The business impact: Benefits for retailers and customers

Final thoughts

如何安装双系统

禁止当前系统索引另外一个系统的文件

渐进式「乾坤大挪移」

后记

Introduction

Types of Normal Forms in Database Normalization

Before we dive into each normal form, here’s a quick visual summary of how 1NF, 2NF, and 3NF differ:

To help you quickly compare the most common normal forms, here’s a summary table outlining their purpose and focus:

Normal Form	Rule Enforced	Problem Solved	Dependency Focus
1NF	Atomicity	Repeating/multi-valued data	None
2NF	Full Dependency	Partial dependency	Composite Primary Key
3NF	Transitive	Transitive dependency	Non-key attributes
BCNF	Superkey Rule	Remaining anomalies	All determinants

Database normalization is structured around a series of increasingly strict rules called normal forms. Each normal form addresses specific types of redundancy and dependency issues, guiding you toward a more robust and maintainable relational schema. The most widely applied normal forms are First Normal Form (1NF), Second Normal Form (2NF), Third Normal Form (3NF), and Boyce-Codd Normal Form (BCNF).

First Normal Form (1NF)

First Normal Form (1NF) is the initial stage in the process of database normalization. It ensures that each column in a table contains only atomic, indivisible values, and that each row is uniquely identifiable. By removing repeating groups and multi-valued attributes, 1NF lays the groundwork for a more organized and consistent database structure. This makes querying, updating, and maintaining data more efficient and reliable, and it helps avoid redundancy right from the beginning of database design.
Key Requirements:

• All columns contain atomic values (no lists, sets, or composite fields).
• Each row is unique (typically enforced by a primary key).
• No repeating groups or arrays within a row.
• Each column contains values of a single data type.

Example: Transforming to 1NF

Suppose you have a table tracking customer purchases, where the “Purchased Products” column contains a comma-separated list of products:

Customer ID	Customer Name	Purchased Products
101	John Doe	Laptop, Mouse
102	Jane Smith	Tablet
103	Alice Brown	Keyboard, Monitor, Pen

Why is this not in 1NF?

• Non-atomic values: “Purchased Products” contains multiple items per cell.
• Querying and updating are complex: Searching for customers who bought “Mouse” requires string parsing.
• Data integrity risks: No way to enforce referential integrity between products and customers.
• Inconsistent data entry: Different delimiters or typos can creep in.

Real-World Impact:

• Reporting (e.g., “Who bought a Laptop?”) is error-prone.
• Updates (e.g., renaming “Mouse” to “Wireless Mouse”) are tedious and unreliable.
• Referential integrity cannot be enforced.

Real-World Issues:

• Reporting challenges: Generating reports such as “How many customers bought a Laptop?” becomes complicated, as you cannot simply filter a column for “Laptop”, you must parse the string.
• Update anomalies: If a product name changes (e.g., “Mouse” to “Wireless Mouse”), you must update every occurrence in every cell, increasing the risk of missing some entries.
• Data integrity risks: There is no way to enforce referential integrity between products and customers, which can lead to orphaned or inconsistent data.

Summary:
This unnormalized table structure is easy to read for small datasets but quickly becomes unmanageable and unreliable as the amount of data grows. To comply with First Normal Form (1NF), we must ensure that each field contains only a single value, and that the table structure supports efficient querying, updating, and data integrity.
Problems with the Unnormalized Table:

• Non-atomic values: The “Purchased Products” column contains multiple items in a single cell, making it difficult to query or update individual products.
• Data redundancy and inconsistency: If a customer purchases more products, the list grows, increasing the risk of inconsistent data entry (e.g., different delimiters, typos).
• Difficulties in searching and reporting: Queries to find all customers who purchased a specific product become complex and inefficient.

Transformation Steps to Achieve 1NF:

1. Identify columns with non-atomic values: In this case, “Purchased Products” contains multiple values.
2. Split the multi-valued column into separate rows: Each product purchased by a customer should be represented as a separate row, ensuring that every field contains only a single value.

Transformed Table in 1NF:

Customer ID	Customer Name	Product
101	John Doe	Laptop
101	John Doe	Mouse
102	Jane Smith	Tablet
103	Alice Brown	Keyboard
103	Alice Brown	Monitor
103	Alice Brown	Pen

Explanation:

• Each row now represents a single product purchased by a customer.
• All columns contain atomic values (no lists or sets).
• The table can be easily queried, updated, and maintained. For example, finding all customers who purchased “Mouse” is now straightforward.

Key Takeaways:

• 1NF requires that each field in a table contains only one value (atomicity).
• Repeating groups and arrays are eliminated by creating separate rows for each value.
• This transformation lays the foundation for further normalization steps by ensuring a consistent and logical table structure.

Key Benefits:

• Simplifies data retrieval.
• Establishes a baseline structure.

Second Normal Form (2NF)

Definition:
A table is in 2NF if it is in 1NF and every non-prime attribute (i.e., non-primary key attribute) is fully functionally dependent on the entire primary key. This addresses partial dependencies, where a non-key attribute depends only on part of a composite key.

Example Transformation to 2NF

1NF Table:

Order ID	Customer ID	Customer Name	Product
201	101	John Doe	Laptop
202	101	John Doe	Mouse
203	102	Jane Smith	Tablet

Issue:
“Customer Name” depends only on “Customer ID”, not the full primary key (“Order ID”, “Customer ID”). This is a partial dependency.
Normalization to 2NF:

• Separate customer information into its own table.

Orders Table:

Order ID	Customer ID	Product
201	101	Laptop
202	101	Mouse
203	102	Tablet

Customers Table:

Customer ID	Customer Name
101	John Doe
102	Jane Smith

Benefits:

• Eliminates redundancy of customer details.
• Simplifies data maintenance and updates.

Third Normal Form (3NF)

Definition:
A table is in 3NF if it is in 2NF and all the attributes are functionally dependent only on the primary key, there are no transitive dependencies (i.e., non-key attributes depending on other non-key attributes).

Example Transformation to 3NF

2NF Table:

Order ID	Customer ID	Product	Supplier
201	101	Laptop	HP
202	101	Mouse	Logitech
203	102	Tablet	Apple

Issue:
“Supplier” depends on “Product”, not directly on the primary key.
Normalization to 3NF:

• Move product and supplier information to separate tables.

Orders Table:

Order ID	Customer ID	Product ID
201	101	301
202	101	302
203	102	303

Products Table:

Product ID	Product Name	Supplier ID
301	Laptop	401
302	Mouse	402
303	Tablet	403

Suppliers Table:

Supplier ID	Supplier Name
401	HP
402	Logitech
403	Apple

Benefits:

• Removes transitive dependencies.
• Reduces data duplication.
• Improves data integrity and maintainability.

Visualizing the 2NF to 3NF Transformation

To further clarify the 2NF to 3NF normalization process and illustrate the elimination of transitive dependencies, refer to the schema diagram below:

This transformation improves maintainability and aligns with best practices for how to normalize a database effectively.

Boyce-Codd Normal Form (BCNF)

Definition:
BCNF is a stricter version of 3NF. A table is in BCNF if, for every non-trivial functional dependency X → Y, X is a superkey. In other words, every determinant must be a candidate key.
When is BCNF Needed?
BCNF addresses certain edge cases where 3NF does not eliminate all redundancy, particularly when there are overlapping candidate keys or complex dependencies.

Example Transformation to BCNF

Let’s walk through a detailed example of how to transform a table that is in Third Normal Form (3NF) but not in Boyce-Codd Normal Form (BCNF).
Scenario:
Suppose we have a university database that tracks which students are enrolled in which courses, and who teaches each course. The initial table structure is as follows:
Original Table:

StudentID	Course	Instructor
1	Math	Dr. Smith
2	Math	Dr. Smith
3	History	Dr. Jones
4	History	Dr. Jones

Explanation of Columns:

• StudentID: Unique identifier for each student.
• Course: The course in which the student is enrolled.
• Instructor: The instructor teaching the course.

Functional Dependencies in the Table:

1. (StudentID, Course) → Instructor
   Each unique combination of student and course determines the instructor for that course.
2. Course → Instructor
   Each course is always taught by the same instructor.

Candidate Keys:

• The only candidate key in this table is the composite key (StudentID, Course), since both are needed to uniquely identify a row.

Why is this Table in 3NF?

• All non-prime attributes (Instructor) are fully functionally dependent on the candidate key (StudentID, Course).
• There are no transitive dependencies (i.e., no non-prime attribute depends on another non-prime attribute through the candidate key).

Why is this Table Not in BCNF?

• The functional dependency Course → Instructor exists, but “Course” is not a superkey (it does not uniquely identify a row in the table).
• BCNF requires that for every non-trivial functional dependency X → Y, X must be a superkey. Here, “Course” is not a superkey, so this violates BCNF.

How to Normalize to BCNF:
To resolve the BCNF violation, we need to decompose the table so that every determinant is a candidate key in its respective table. This is done by splitting the original table into two separate tables:

1. StudentCourses Table:
   This table records which students are enrolled in which courses.
   

   StudentID	Course
   1	Math
   2	Math
   3	History
   4	History

   • Primary Key: (StudentID, Course)
   • This table no longer contains the Instructor column, so there are no functional dependencies that violate BCNF.
2. CourseInstructors Table:
   This table records which instructor teaches each course.
   

   Course	Instructor
   Math	Dr. Smith
   History	Dr. Jones

   • Primary Key: Course
   • The dependency Course → Instructor is now valid, as “Course” is the primary key (and thus a superkey) in this table.

Resulting Structure and Benefits:

• All functional dependencies in both tables have determinants that are candidate keys, so both tables are in BCNF.
• Data redundancy is reduced: the instructor for each course is stored only once, rather than repeated for every student enrolled in the course.
• Updates are easier and less error-prone: if an instructor changes for a course, you only need to update one row in the CourseInstructors table.

Summary Table of the Decomposition:

Table Name	Columns	Primary Key	Purpose
StudentCourses	StudentID, Course	(StudentID, Course)	Tracks which students are in which courses
CourseInstructors	Course, Instructor	Course	Tracks which instructor teaches each course

By decomposing the original table in this way, we have eliminated the BCNF violation and created a more robust, maintainable database structure.
Summary:
Applying these normal forms in sequence helps you design databases that are efficient, consistent, and scalable. For most practical applications, achieving 3NF (or BCNF in special cases) is sufficient to avoid the majority of data anomalies and redundancy issues.

-- Example: Creating separate tables for normalization
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    CustomerName VARCHAR(100)
);

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    Product VARCHAR(100),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

The setup: Revisiting OctoArcade (and its bugs)

• Problem: Navigation header overlapping game content across all games
• Solution: Copilot agent mode and Playwright MCP server identified the issue through visual inspection, and implemented a global header fix
• Bonus: Fixed some additional UI issues (unintended gaps between the game canvas and footer) discovered during testing
• Result: Hands-off debugging that solved problems I’d stepped away from, and had previously spent some cycles on fixing

Making sure Copilot custom instructions are set up

Based on the #codebase, please can you update the custom instructions file for accuracy? Please make sure to keep the structure (i.e. headings etc.) as-is. Thanks!

Agentic debugging: UI troubleshooting with Playwright MCP

• Load web pages
• Simulate user actions (clicks, navigation)
• Inspect rendered layouts without needing vision models

{

  "mcpServers": {

    "playwright": {

      "command": "npx",

      "args": ["@playwright/mcp@latest"]

    }

  }

}

• browser_snapshot – Capture accessibility snapshots of pages
• browser_navigate – Navigate to URLs
• browser_click, browser_type, browser_hover – Interact with elements
• browser_resize – Test different viewport sizes
• browser_take_screenshot – Visual documentation
• And many more: You can find the full list in the tools section of Playwright MCP server’s README

The debugging journey: Real-time fixes and lessons learned

1. Describe the problem and let agent mode work

I have spotted that there is a bit of a UI error. It seems like the main content of any page "starts" behind the navigation bar. This is more evident on the games like octosnap, octopong and octobrickbreaker.

Can you take a look at the site using Playwright (you'll need to spin up an instance of the server), take a look at the pages, and then investigate? Thanks!

Sorry, I wanted you to take a look when a game is actually loaded too. Can you play the game Octopong and Octosnap – I think it’s very visible in those? Do that before you build a plan.

• Launch a browser
• Navigate through the app’s pages
• Diagnose where and why content was hidden or misaligned

2. Iterating on UI requirements

Practical tips: Working with Copilot agent mode and MCP servers

• Keep Copilot custom instructions up to date: The agent relies on these files for repo context and best practices.
• Give Copilot more power with MCP: Playwright MCP enables true end-to-end testing and UI inspection, making it invaluable for debugging complex web apps.
• Be explicit with requirements: Like any collaborator, Copilot only knows what you tell it. List out your must-haves, expected behaviors, and edge cases.
• Iterate in small steps: Commit changes frequently. It’s easier to roll back and diagnose issues when your history is granular.

Conclusion: Progress, not perfection

1. Agentic tools like Copilot and Playwright MCP can genuinely accelerate troubleshooting. Especially when you provide the right context.
2. Describing requirements is hard. And that’s okay! Iteration, feedback, and even a few missteps are part of the process (both in terms of learning, and solving bugs).

1. Update Copilot custom instructions files for your repo. If you’re using Copilot coding agent, make sure to configure the copilot-setup-steps.yml.
2. Install and start the Playwright MCP server in VS Code to provide Copilot access to a browser for UI testing.
3. Describe your bug or feature clearly in a new chat with Copilot agent mode.
4. Let Copilot propose and apply fixes. But always review code changes and test results.
5. Iterate on requirements based on what you see. Clarify as needed. Make sure you’re being clear in your requirements too.
6. Commit frequently! Work in a branch and save your progress at each step.

1. 项目集的全部任务、甘特图、资源管理支持视图；
2. 项目集的全部任务支持设置默认表头；

项目集的优化

支持视图

1. 在项目集的“全部任务”页面，点击「新建视图」，即可创建一个新的视图；
2. 然后在视图设计器中选择分组、排序、展示方式、查询条件，然后保存，即可完成视图的创建（对于资源管理，没有此步骤）。

支持设置默认表头

其他优化

任务附件通知

审批

I am five years old

I am eleven years old

I am twelve or thirteen years old

I am fourteen years old

I am still fourteen years old

I am sixteen years old

I am eighteen years old

I am thirty-two years old

I am thirty-eight years old

• A man ten years my elder used me for sex.
• A bunch of adult men used me for laughs.
• Some kind of gossip ring used me for, well, gossip.
• A con staff member used me to vent about something that, frankly, furry conventions seemed to deal with a lot in the 00s.