Generative AI for Software Architecture and Design
NOTE:
The content in this series has been written by a human. Exceptions include AI-generated images and code segments demonstrating the various capabilities of the referenced AI tools.
The AI-Driven SDLC
This is the third article in the series The AI-Driven SDLC, focused on Generative AI, and its practical use in all phases of the software development lifecycle. The other articles in this series include:
Introduction
In the first instalment of the series, we looked into the AI-Driven SDLC and the role Generative AI can play in every phase of the development lifecycle. In the second article we provided examples on how GenAI can aid the busy product manager.
In this round, we take a closer look into the practice of Software Architecture and Design and explore how GenAI can help in creating architectural designs, detecting patterns and providing suggestions on how to improve our designs. It is a fun and exciting journey, so let's get started!
What is Software Architecture?
Architects create the blueprints and fundamental building blocks of any software system. They also guide the creation of design patterns, repeatable building blocks (libraries, code structures) that make up the structure of the solution. In large projects architecture may be the responsibility of a separate group, while in smaller teams developer-architects are the ones that define, design and build the entire solution.
According to Martin Fowler, software architects posses the ability to recognise the important elements in a large system of entities:
...the heart of thinking architecturally about software is to decide what is important, (i.e. what is architectural), and then expend energy on keeping those architectural elements in good condition. For a developer to become an architect, they need to be able to recognise what elements are important, recognising what elements are likely to result in serious problems should they not be controlled.
Good software architects utilise a number of techniques, keep their toolset current and ground their designs on a multitude of factors, including:
The software architects of today recognise that GenAI is one of the tools available to make their life easier and utilise this advancement to come up with better designs faster and create more impact.
Architecture vs Design: What's the Difference?
When it comes to architecture vs. design, there are many definitions, and some are more confusing than others.
In its most basic form, software architecture is the art and science of defining the high-level skeleton of a system. It defines the various modules, systems and subsystems, what and where these modules reside and at a high-level, the relationship between these modules. It does not go into describing the inner workings of each module or subsystem.
Design, on the other hand, is the detailed description and specification of each module, including detailed interface definitions, relationship graphs, and interaction sequences.
From these definitions, it should be clear that architecture and design are two fairly distinct activities, especially for large systems. While in a small team, the architect, designer and developer can be all one person, large teams can employ teams of architects, designers and developers with distinct skills and areas of specialisation. For large teams, specialisation brings better quality and depth to the design artefacts produced, however communication and using a consistent technical nomenclature can become a problem. GenAI, especially when fine-tuned to a specific domain, can help solve communication and nomenclature problems with its ability to generate architectural assets and summarise long textual documents, such as business cases and user stories. In this article we will look into examples that apply to both architecture and design.
GenAI for Software Architects
Software architects consider myriad of data points when designing the most appropriate structure of a system:
In the process, architects create design assets for others to consume. These can be text documents, diagrams, blueprints or common architectural assets. Similar to product management, these assets can be used by internal customers or distributed to outside groups, including customers, prospects or presented at industry conferences.
Let us take a look at some of the activities and assets produced during this phase:
A comprehensive list is beyond the scope of this article and can vary depending on the project and the domain. What remains similar though, is the amount of rigour and consistency needed to maintain a [large] library of architectural assets in line with the accepted and communicated standards and current with the software being built or running in production.
GenAI can help generate some of the architectural assets necessary with relative ease, however to increase the quality of the generated assets several factors must be considered:
Architecting the Dog Walking App
In a previous article we defined a dog walking mobile app as a reference app to demonstrate the capabilities of ChatGPT, Bard and others in aiding the product managers. In this article we will continue to build on the same example and look into AI tools for generating architectural assets. To improve the accuracy of the generated answers we will set up our prompts with the following pre-prompt:
You are a software architect for a startup revolutionising the pet-walking industry...
In the next series of prompts, we will ask AI to generate data models, ERD, SQL, diagrams and more, recommendation for tech stacks and a user authentication framework.
Let's get started.
Prompt Examples
Generate a Data Model
Our app relies on the data it can store and access in the database. Although we haven't settled on a database vendor or technology (SQL, NoSQL, GraphDB), a relational data model can help in exploring the relationships among entities in the system.
In this example we will ask ChatGPT to create a relational data model.
Prompt:
Can you design the data model for this app?
And the answer is fairly comprehensive, if limited to four entities. It also makes a clear note that the database technology (SQL vs. NoSQL) should be considered before creating more entities. Still, the generated data model provides a good foundation for further research.
Certainly! Here's a suggested data model for the pet walking app:
1. User:
? ?- id: Unique identifier for each user.
? ?- name: User's full name.
? ?- email: User's email address (used for authentication and communication).
? ?- password: Hashed password for user authentication.
? ?- role: User role (e.g., pet owner, pet walker, admin).
? ?- profilePicture: URL or reference to the user's profile picture.
? ?- phoneNumber: User's phone number.
? ?- address: User's address details (street, city, state, postal code).
2. Pet:
? ?- id: Unique identifier for each pet.
? ?- ownerId: Foreign key referencing the User who owns the pet.
? ?- name: Pet's name.
? ?- breed: Pet's breed or species.
? ?- age: Pet's age.
? ?- weight: Pet's weight.
? ?- notes: Additional notes or special instructions for the pet.
3. PetWalker:
? ?- id: Unique identifier for each pet walker.
? ?- name: Pet walker's full name.
? ?- bio: Description or bio of the pet walker.
? ?- experience: Pet walker's experience in handling pets.
? ?- rating: Average rating or feedback score of the pet walker.
4. PetWalkingSession:
? ?- id: Unique identifier for each walking session.
? ?- petId: Foreign key referencing the Pet associated with the walking session.
? ?- walkerId: Foreign key referencing the PetWalker assigned to the walking session.
? ?- ownerId: Foreign key referencing the User who owns the pet.
? ?- scheduledTime: Date and time of the scheduled walking session.
? ?- duration: Duration of the walking session.
? ?- status: Current status of the walking session (e.g., scheduled, in progress, completed).
This data model covers the essential entities and their relationships in the pet walking app. It includes User and Pet entities for managing user profiles and pet information. Additionally, there's a PetWalker entity to store information about pet walkers, and a PetWalkingSession entity to track scheduled walking sessions.
Please note that this is a simplified data model, and depending on your app's requirements, additional entities and relationships may be necessary. It's recommended to further refine the data model based on your specific use cases, such as adding tables for reviews/ratings, notifications, and payments, if needed.
Also, remember to consider the database technology you'll be using (e.g., PostgreSQL, MongoDB) and design the data model accordingly, leveraging the capabilities and features of the chosen database system.
Generate the SQL Code
Now that we have a data model, can we generate the DDL in order to run it in an RDBMS such as PostgreSQL? Let's give it a try.
Prompt:
Can you create the SQL for this model?
The produced SQL code is below:
领英推荐
Certainly! Here's an example of SQL statements for creating the tables based on the data model described:
```sql
-- User table
CREATE TABLE User (
? id INT PRIMARY KEY,
? name VARCHAR(255),
? email VARCHAR(255),
? password VARCHAR(255),
? role VARCHAR(50),
? profilePicture VARCHAR(255),
? phoneNumber VARCHAR(20),
? address VARCHAR(255)
);
-- Pet table
CREATE TABLE Pet (
? id INT PRIMARY KEY,
? ownerId INT,
? name VARCHAR(255),
? breed VARCHAR(255),
? age INT,
? weight DECIMAL(5,2),
? notes TEXT,
? FOREIGN KEY (ownerId) REFERENCES User(id)
);
-- PetWalker table
CREATE TABLE PetWalker (
? id INT PRIMARY KEY,
? name VARCHAR(255),
? bio TEXT,
? experience INT,
? rating DECIMAL(3,2)
);
-- PetWalkingSession table
CREATE TABLE PetWalkingSession (
? id INT PRIMARY KEY,
? petId INT,
? walkerId INT,
? ownerId INT,
? scheduledTime DATETIME,
? duration INT,
? status VARCHAR(50),
? FOREIGN KEY (petId) REFERENCES Pet(id),
? FOREIGN KEY (walkerId) REFERENCES PetWalker(id),
? FOREIGN KEY (ownerId) REFERENCES User(id)
);
```
The SQL statements above create the necessary tables with the respective columns and define the relationships between the tables using foreign key constraints. Adjust the column types and lengths as per your specific requirements, and you can also add additional columns or constraints as needed.
Please note that this SQL example assumes the use of a relational database such as MySQL or PostgreSQL. If you plan to use a different database system or ORM, the syntax and data types may vary. Make sure to refer to the documentation of your chosen database system for the precise syntax and any additional configuration specific to that system.
Generate an Entity Relationship Diagram (ERD)
After the data model and the SQL code, the next step is to get a diagram so we can visualise the structure and the relationship of the entities in the data model. Let us ask ChatGPT to create it for us.
Prompt:
Can you generate an ERD diagram based on this model?
The produced diagram looks like this:
Certainly! Here's an Entity-Relationship Diagram (ERD) representing the data model described for the pet walking app:
```
? ? ? ?+--------------+? ? ? ? ?+-------------+
? ? ? ?|? ? User? ? ? |? ? ? ? ?|? ? ?Pet? ? ?|
? ? ? ?+--------------+? ? ? ? ?+-------------+
? ? ? ?| id? ? ? ? ? ?|1? ? ? ? | id? ? ? ? ? |
? ? ? ?| name? ? ? ? ?|--------<| ownerId? ? ?|
? ? ? ?| email? ? ? ? |? ? ? ? ?| name? ? ? ? |
? ? ? ?| password? ? ?|? ? ? ? ?| breed? ? ? ?|
? ? ? ?| role? ? ? ? ?|? ? ? ? ?| age? ? ? ? ?|
? ? ? ?| profilePicture |? ? ? ? | weight? ? ? |
? ? ? ?| phoneNumber? |? ? ? ? ?| notes? ? ? ?|
? ? ? ?| address? ? ? |? ? ? ? ?+-------------+
? ? ? ?+--------------+
? ? ? ? +-----------------+
? ? ? ? |? ?PetWalker? ? ?|
? ? ? ? +-----------------+
? ? ? ? | id? ? ? ? ? ? ? |
? ? ? ? | name? ? ? ? ? ? |
? ? ? ? | bio? ? ? ? ? ? ?|
? ? ? ? | experience? ? ? |
? ? ? ? | rating? ? ? ? ? |
? ? ? ? +-----------------+
? ? ? ? ? ? ? ?|
? ? ? ? ? ? ? ?|
? ? ? ? ? ? ? ?|1
? ? ? ? ? ? ? ?|
? ? ? ? +----------------------+
? ? ? ? | PetWalkingSession? ?|
? ? ? ? +----------------------+
? ? ? ? | id? ? ? ? ? ? ? ? ? ?|
? ? ? ? | petId? ? ? ? ? ? ? ? |
? ? ? ? | walkerId? ? ? ? ? ? ?|
? ? ? ? | ownerId? ? ? ? ? ? ? |
? ? ? ? | scheduledTime? ? ? ? |
? ? ? ? | duration? ? ? ? ? ? ?|
? ? ? ? | status? ? ? ? ? ? ? ?|
? ? ? ? +----------------------+
```
In this ERD, each entity is represented as a box, and the relationships between entities are depicted using lines connecting them. The relationship type is indicated by the symbols at the ends of the lines. For example, "1" indicates a one-to-one relationship, and "--<" indicates a one-to-many relationship.
The User entity has a one-to-many relationship with the Pet entity, as one user can own multiple pets. The Pet entity has a foreign key (ownerId) referencing the User entity.
The PetWalkingSession entity has foreign keys (petId, walkerId, ownerId) referencing the Pet, PetWalker, and User entities, respectively. This indicates that a pet walking session is associated with one pet, one pet walker, and one pet owner.
Please note that this is a simplified representation of the data model, and it's important to adjust and refine it based on the specific requirements of your pet walking app. The ERD provides a visual overview of the relationships between entities and serves as a helpful reference during the development process.
This is a fairly good visualisation, however we can take it a step further and ask for the Mermaid script for the same diagram. Let us try that. Prompt:
Can you create the mermaid script of this diagram?
The produced Mermaid script code looks like this:
Certainly! Here's the Mermaid script representing the Entity-Relationship Diagram (ERD) for the pet walking app:
```mermaid
erDiagram
User ||--o{ Pet : "owns"
PetWalker ||--|{ PetWalkingSession : "assigned to"
User {
int id
varchar(255) name
varchar(255) email
varchar(255) password
varchar(50) role
varchar(255) profilePicture
varchar(20) phoneNumber
varchar(255) address
}
Pet {
int id
int ownerId
varchar(255) name
varchar(255) breed
int age
decimal(5) weight
text notes
}
PetWalker {
int id
varchar(255) name
text bio
int experience
decimal(3) rating
}
PetWalkingSession {
int id
int petId
int walkerId
int ownerId
datetime scheduledTime
int duration
varchar(50) status
}
```
The above Mermaid script defines the entities (User, Pet, PetWalker, PetWalkingSession) and their attributes using the Mermaid syntax. The relationships between the entities are represented by the `||--o{`, `||--|{`, and `--<` syntax.
Make sure to use a Mermaid-enabled environment or tool (such as the Mermaid Live Editor) to render the script and visualize the ERD.
When pasted into the Mermaid Online Editor, this code produces the following diagram:
Create a Sequence Diagram
Now, let's take a look at the interactions among modules in the system. Let us look at the sequence of events for a sample use case.
In this prompt, we will ask ChatGPT to create a sequence diagram code for a simple use case:
Please create a sequence diagram of the use case "As a pet owner, I want to schedule a pet walking session."
And... the result:
Certainly! Here's a sequence diagram for the first use case: "As a pet owner, I want to schedule a pet walking session."
```mermaid
sequenceDiagram
? ? participant PetOwner
? ? participant App
? ? participant Backend
? ? participant PetWalker
? ? PetOwner->>App: Launches the app
? ? App->>Backend: Fetches available pet walkers
? ? Backend->>PetWalker: Get available walkers
? ? PetWalker-->>Backend: Returns list of available walkers
? ? Backend-->>App: Sends list of available walkers
? ? App->>PetOwner: Displays list of available walkers
? ? PetOwner->>App: Selects a pet walker
? ? App->>Backend: Sends request to schedule a session
? ? Backend-->>App: Validates request
? ? App->>PetWalker: Sends request to schedule a session
? ? PetWalker-->>Backend: Confirms availability
? ? Backend-->>App: Sends confirmation
? ? App->>PetOwner: Sends confirmation to pet owner
? ? PetOwner->>App: Confirms the session
? ? App->>Backend: Confirms the session
? ? Backend->>PetWalker: Notifies pet walker about the confirmed session
? ? PetWalker-->>Backend: Acknowledges the notification
? ? Backend-->>App: Acknowledges the confirmation
? ? App-->>PetOwner: Confirms the session
```
In this sequence diagram, the interactions between the participants (PetOwner, App, Backend, PetWalker) are visualized. Here's a step-by-step breakdown of the interactions:
1. The PetOwner launches the app.
2. The App fetches the available pet walkers from the Backend.
3. The Backend retrieves the list of available walkers from the PetWalker.
4. The Backend sends the list of available walkers to the App.
5. The App displays the list of available walkers to the PetOwner.
6. The PetOwner selects a pet walker.
7. The App sends a request to the Backend to schedule a session.
8. The Backend validates the request.
9. The App sends a request to the selected PetWalker to schedule a session.
10. The PetWalker confirms their availability to the Backend.
11. The Backend sends the confirmation to the App.
12. The App sends the confirmation to the PetOwner.
13. The PetOwner confirms the session.
14. The App confirms the session with the Backend.
15. The Backend notifies the PetWalker about the confirmed session.
16. The PetWalker acknowledges the notification to the Backend.
17. The Backend acknowledges the confirmation to the App.
18. The App confirms the session with the PetOwner.
This sequence diagram illustrates the flow of interactions between the different components of the system to schedule a pet walking session.
And similar to the ERD, when pasted into the Mermaid Online Editor, this sequence diagram script produces the following picture:
In this simple diagram we can see the interaction among various entities and the sequence and type (sync/async) of the messages in the system.
Tech Stack Definition
Now that we have a data model, SQL, ERD and a basic sequence diagram, let us get some recommendations for the tech stack to implement this app. As a mobile app with a data backend, we are interested in the coding languages, platforms and cloud providers that GenAI will recommend. Let's give it a try:
Can you recommend a tech stack to implement this app?
ChatGPT does not hesitate:
Certainly! Here's a recommended tech stack for implementing a pet walking app
1. Mobile App Development:
? ?- For iOS: Swift programming language using Xcode IDE.
? ?- For Android: Java or Kotlin programming language using Android Studio IDE.
? ?- Alternatively, you can consider cross-platform frameworks like React Native or Flutter to build both iOS and Android apps simultaneously.
2. Backend Development:
? ?- Language: Node.js or Python for server-side development.
? ?- Frameworks: Express.js (Node.js) or Django (Python) for building RESTful APIs.
? ?- Database: PostgreSQL, MySQL, or MongoDB for data storage.
? ?- Authentication: JSON Web Tokens (JWT) for secure authentication.
? ?- Real-time Notifications: Firebase Cloud Messaging (FCM) or Pusher for push notifications.
3. Frontend Development:
? ?- Web Technologies: HTML5, CSS3, and JavaScript for web-based components.
? ?- Frameworks: React.js or Angular for building interactive user interfaces.
? ?- State Management: Redux or MobX for managing application state.
? ?- UI Design: Use popular UI libraries like Material-UI or Bootstrap for a consistent and responsive design.
4. Maps and Navigation:
? ?- Google Maps API or Mapbox API for displaying maps, geocoding, and navigation features.
? ?- Integration with respective mobile platforms for accessing device GPS and location services.
5. Real-time Communication:
? ?- WebSockets: Socket.IO or SockJS for real-time communication between pet owners and walkers.
? ?- Alternatively, you can use Firebase Realtime Database or Firestore for real-time updates.
6. Payment Integration:
? ?- Payment Gateways: Stripe, PayPal, or Braintree for secure and seamless payment processing.
? ?- Implement APIs or SDKs provided by the chosen payment gateway to handle transactions.
7. Cloud Hosting:
? ?- Infrastructure: AWS (Amazon Web Services), Google Cloud Platform, or Microsoft Azure for scalable and reliable cloud hosting.
? ?- Deployment: Containerization with Docker and container orchestration with Kubernetes for easy deployment and scaling.
Remember that the choice of the tech stack may also depend on the expertise of your development team, their familiarity with specific technologies, and the scalability and performance requirements of your pet walking app. It's always recommended to conduct a thorough evaluation and consider factors like development cost, community support, and compatibility before finalizing the tech stack for your project.:
Sounds pretty good, but what if the tools or platforms proposed do not fit your current stack or are not part of your technical roadmap? Then, you can simply ask AI to regenerate the answer using your specific technical requirements and constraints:
Yes, but I want everything as serverless APIs
ChatGPT changes its recommendations like so:
Certainly! If you prefer a serverless architecture for your pet walking app, here's a recommended tech stack for implementing serverless APIs:
1. Backend Development:
? ?- AWS Lambda: Serverless compute service for running backend logic.
? ?- AWS API Gateway: Fully managed service for creating and managing APIs.
? ?- AWS DynamoDB: NoSQL database service for storing pet, user, and session data.
? ?- AWS Cognito: User authentication and authorization service.
? ?- AWS S3: Object storage for storing images, documents, or other files.
? ?- AWS Step Functions: For orchestrating complex workflows and business processes.
? ?- AWS EventBridge: For event-driven architecture and handling pub/sub messaging.
? ?- AWS CloudFormation: Infrastructure as code for managing and deploying resources.
2. Frontend Development:
? ?- React.js or Angular: JavaScript frameworks for building dynamic user interfaces.
? ?- AWS Amplify: Simplifies frontend development and provides integration with AWS services.
? ?- AWS SDKs: Use AWS SDKs in your frontend code to interact with serverless APIs.
3. Maps and Navigation:
? ?- AWS Location Service: Provides geocoding, maps, and routing functionalities.
? ?- Integrate AWS Location Service APIs to display maps and perform geolocation tasks.
4. Real-time Communication:
? ?- AWS AppSync: Managed service for building real-time applications with GraphQL.
? ?- Use AWS AppSync subscriptions for real-time updates between pet owners and walkers.
5. Payment Integration:
? ?- Stripe API or PayPal API: Use serverless functions to integrate with the chosen payment gateway APIs.
6. Cloud Hosting:
? ?- AWS Lambda: Run serverless functions for the backend logic.
? ?- Amazon API Gateway: Manage serverless APIs and define endpoints.
? ?- Amazon S3: Store static assets like HTML, CSS, and JavaScript files.
By leveraging serverless technologies from AWS, you can benefit from automatic scalability, pay-as-you-go pricing, and reduced operational overhead. The serverless architecture allows you to focus more on the app's functionality rather than managing infrastructure.
Keep in mind that implementing a serverless architecture requires expertise in cloud services, event-driven design, and serverless best practices. It's recommended to have a proficient development team with experience in serverless application development or consider consulting with a cloud solutions architect to ensure an effective and optimized implementation of the serverless tech stack for your pet walking app.
Here again we can see ChatGPT coming up with a number of recommended cloud tools, and a vendor selection, in this case the AWS. If that's not in your bag, then simply ask to use a different vendor such as Azure or Google Cloud and ChatGPT will create a recommendation based on your preferences.
User Authentication Using Serverless Backend
For this last example we will ask ChatGPT to create a sample user authentication flow using serverless technology:
For user management I want to use auth0 and serverless. Can you describe the sign up and sign in flows?
And... here we go! We have our user flow using auth0:
Certainly! Here's an overview of the sign-up and sign-in flows using Auth0 and a serverless architecture:
Sign-up Flow:
1. The user opens the pet walking app and clicks on the "Sign up" button.
2. The app redirects the user to the Auth0 sign-up page or displays a custom sign-up form integrated with Auth0.
3. The user enters their email address and password, and any additional required information.
4. Auth0 validates the input and creates a new user account, storing the user's credentials securely.
5. Upon successful sign-up, Auth0 generates an authentication token (JWT) for the user.
6. The app receives the authentication token from Auth0 and securely stores it on the client-side (e.g., using local storage).
7. The user is now signed up and authenticated, allowing them to access app features and functionality.
Sign-in Flow:
1. The user launches the pet walking app and clicks on the "Sign in" button.
2. The app redirects the user to the Auth0 sign-in page or displays a custom sign-in form integrated with Auth0.
3. The user enters their registered email address and password.
4. Auth0 verifies the user's credentials and authenticates the user.
5. Upon successful authentication, Auth0 generates a new authentication token (JWT) for the user.
6. The app receives the authentication token from Auth0 and securely stores it on the client-side.
7. The user is now signed in and can access the app's features and functionality.
Additional Considerations:
- Auth0 provides various authentication options, such as social login (e.g., Google, Facebook), multi-factor authentication, and passwordless login. These options can be integrated into the sign-up and sign-in flows based on your app's requirements.
- Auth0 offers customizable email verification and password reset flows, allowing users to confirm their email addresses and reset their passwords if needed.
- You can configure Auth0 to support role-based access control (RBAC) to manage user permissions and restrict access to certain app features based on user roles.
It's important to refer to the official documentation and guides provided by Auth0 to implement the sign-up and sign-in flows securely and effectively. These flows can be integrated with your serverless architecture by invoking serverless functions to handle the authentication requests and communicate with Auth0 APIs for user management operations.
ChatGPT suggested a Sign Up as well as the Sign In flows using auth0. That's a good foundation for the detailed designs that will follow.
Conclusion
The job of the software architect today can be greatly enhanced and augmented by GenAI. The boundaries of what's possible are constantly challenged and new tools provide new capabilities at a breakneck pace.
As architects, one of our challenges now is keeping up with the advancements in the space.
Armed with the right tools - a great foundational LLM, data for fine-tuning, and a set of plugins for diagramming and accessing external APIs - the architects of today can improve their efficiency, communicate more effectively, reduce the jargon barriers in cross-functional teams and become more valuable to their organisation.
In this article we explored a small selection of tasks and tools available to architects. Over time, more specialised tools, better trained models and plugins will become available. These tools will be designed specifically for software architecture and will likely help double, triple, even quadruple the efficiency of the workforce.
IDEs, architecture design apps, cloud consoles and enterprise apps will all integrate GenAI into their interface, so architects can create assets without leaving their native environments.
Generative AI is changing the shape of technology teams and architects are poised to benefit the most from this new enablement. The technology is available, it works, the costs are manageable and the generated results are promising.
I hope this introductory article will inspire you to experiment further and discover more creative ways to utilise GenAI to create better Software Architecture and Design.
Building Trophée (World's First Game Commerce Company) | Ex Tech Founder at NATIVV (Asia's first In-Game advertising Co.) | SH Partner at iion | Game Tech Expert
8 个月Excellent explanation! You've clearly broken down the concept in a way that's easy to follow.
Digital Experience Lead at Coutts
1 年I've just stumbled across this article and it's brilliant! Thanks for writing it. I'm no architect, but simplistically speaking the use of GenAI in helping me provide the right foundational user stories to architects and give them a head-start in development could be a great outcome from using the tech in the right way. Brilliant stuff.
Thanks for Sharing! ?? @
Managing Director at Accenture | Tech & Organizational Transformation | Leadership | Strategy to Implementation | ?? me!
1 年Great series and yet another great article, Lev Z. - thanks for walking through hands on demonstrations!