Master the key information of the full collaborative design pipeline: turn meeting notes written in natural language into data structures (Mermaid ERD), build a project standard term dictionary, analyze the impact of design changes and preserve decisions.
In real projects, misunderstandings between planning, design and development lead directly to missing database items and broken consistency. Let's see why guaranteeing consistency at the design stage matters.
Looking at the same screen plan, planners, designers and developers picture different data models and relationships, which ends in gaps or data mismatches (runtime errors).
Using different names for the same subject, like 'member, customer, User, Member', creates big unnecessary translation and communication rework costs when naming variables.
Fixing only the DB schema for a sudden new service policy without updating the API or screen plan makes system mismatches snowball and can bring the system down.
Compare ChatGPT, limited to a single chat context, with Codex Client, which understands the whole folder structure and dependencies between files.
| Compared | ChatGPT (general chat AI) | Codex Client (Workspace-based AI) |
|---|---|---|
| Context awareness | Understands only the single file/text the user pastes, locally | Understands the dependencies between DDL schema, plans and API specs in the folder at the same time |
| Term standardization | Stays at one-off translation; can't keep variable names consistent across the project | Recommends consistent standard names and DB column names based on the project term dictionary |
| Impact analysis | Suggests isolated schema errors or made-up table fixes | Works backward from small schema changes (e.g. adding a column) to list API specs and screen parts to fix |
The list of final outputs learners create during the Day 3 session, and the purpose of each.
A Mermaid ERD script and spec rendering entities and relationships pulled from a natural-language plan (output: erd-schema.md)
A project standard term dictionary defining scattered planning terms as standard English columns (output: project-glossary.md)
A change impact analysis listing API and screen fixes for adding booking approval (WAIT_APPROVE) (output: change-impact-report.md)
A Design Decision Log (DDL) archiving the reasons for normalization and data design decisions and rejected alternatives (output: design-decision-log.md)
An Edge Case analysis report with DB improvements for concurrent payment errors, data lost on account deletion (referential integrity) and transaction rollback (output: edge-case-analysis.md)
A mapping of the inputs used in the lab and the outputs produced through Codex Workspace reasoning.
Enter the meeting scenario prose and derive precise normalized relationships (1:N, 1:1) and Mermaid code.
Analyze the provided meeting notes from a data structure view, derive the key entities and relationships, and write a data structure doc and Mermaid ERD code.
Compare the gap between Figma plan terms and DB dev specs and build a domain term master dictionary.
Analyze all the terms mixed across the project, like 'member/User/customer/Member' and 'counselor/Expert/teacher/Counselor', and write a project standard term dictionary as a Markdown table.
Find the API and table impact when the release plan changes to add an 'approval' step to booking.
The booking confirmation process changes to add a 'waiting for approval' state and 'pay after expert approval'. Write the affected API specs, DB schema, screens and a change sharing report.
Log the rejection reasons and agreements for normalization decisions, splitting booking history physically, and so on.
Extract normalization and database structure decisions from the meeting and write a Design Decision Log including the decision item, background reason, alternatives reviewed, approver and chance of future change.
Audit system weak points to prevent referential integrity violations (account deletion) and broken transactions.
Derive Edge Case exception scenarios that break data consistency in the currently defined User, Expert, Reservation and Payment table structure, and suggest improvements.
Going beyond simple text matching, it understands entity referential integrity (FK) and transaction lifecycles, and works backward from a natural-language plan to DDL (Data Definition Language) queries and state machine rules automatically.
It groups differently written terms (customer name vs Nickname) by meaning (Clustering) to produce a company-wide term master dictionary, and syncs the data dictionary's consistency based on it.
See how data and analysis from each step go around the technical design loop to maximize quality.
This 5-step loop blocks exceptions at the source from the planning and design stage, giving developers who start coding a big productivity boost and removing human error.
Topics that work well for class discussion or interview questions.
"If you choose Soft Delete (logical delete) instead of Hard Delete for account deletion, what are the performance downsides, and what index/DB partitioning strategy can make up for them?"
"If a project runs to the middle without a standard term dictionary, how does the 'terminology debt' inside the dev team affect the real schedule?"
An overview of all the lab tasks and missions covered on Day 3.
| Task | Topic | How AI is used |
|---|---|---|
| Task 01 | Resolve data structure misunderstandings | Turn meeting content into a data structure and organize entities and relationships |
| Task 02 | Term standardization | Analyze terms across the project and create a standard term dictionary |
| Task 03 | Share change impact | Analyze the impact of design changes and trace related docs and features |
| Mission 01 | Record design decisions | Write a Decision Log to manage design reasons and change history |
| Mission 02 | Find exception scenarios | Analyze missing Edge Cases and work out risks and improvements |