Absolutely. For Using Projects, I suggest we make this article more practical than the previous Creating Your First Project article. The previous post explained how to create a Project; this one should explain how to actually use it effectively for ongoing AI Agent development.
Using Projects in ChatGPT
In the previous post, we created our first ChatGPT Project and learned how to configure it with instructions, files, and conversations.
In this post, we will learn how to use Projects effectively for long-running work and, in particular, how Projects can help us organize an AI Agent development project.
What Can You Do With a Project?
A ChatGPT Project provides a workspace where you can keep related:
- Conversations
- Files
- Instructions
- Research
- Project context
together.
Instead of starting a completely new conversation every time you work on your project, you can continue working inside the same Project.
For example, if you are developing an AI Agent, you can keep the architecture discussion, requirements, source documents, programming questions, and testing discussions inside one Project.
1. Start With Project Instructions
Project instructions are one of the most useful features.
They tell ChatGPT how you want it to behave within the Project.
For example, for an AI Agent development Project, you could use:
Act as a senior software architect and AI Agent development mentor. Help me design and build an AI Agent step by step. Explain technical concepts clearly and provide practical examples. Prefer C# and .NET examples unless another language is requested. Focus on secure, maintainable, production-oriented solutions.
You don’t need to repeat these instructions in every conversation.
2. Keep Related Conversations Together
A Project can contain multiple conversations.
For example, an AI Agent Development Project could contain:
Conversation 1 – Requirements
Define the requirements for my AI Agent.
Conversation 2 – Architecture
Design the architecture based on the requirements.
Conversation 3 – LLM
Which LLM should we use and why?
Conversation 4 – Tools
What tools should the Agent have?
Conversation 5 – Memory
Design the memory system.
Conversation 6 – RAG
How should we implement RAG?
Conversation 7 – Security
Identify security risks.
Each conversation can focus on a particular part of the project.
3. Add Reference Files
You can add relevant files to your Project and use them as reference material.
For example:
- Requirements documents
- PDF documentation
- Word documents
- Excel files
- Architecture diagrams
- Source code
- API documentation
After adding a document, you can ask:
Summarize the requirements in this document.
Or:
Identify the requirements related to authentication.
This avoids repeatedly uploading the same information in different conversations.
4. Use Project Context
One of the main advantages of Projects is that they provide a common context for related work.
For example, suppose your Project contains:
Project instructions
We are developing a customer-support AI Agent using C# and .NET.
Reference file
Customer requirements document
Previous conversation
Discussion about the Agent architecture.
You can then start another conversation and ask:
Based on our requirements and architecture, what tools should our Agent have?
The Project provides the context that makes this type of ongoing work easier.
Project memory and context behavior can depend on your settings and the type of Project you create. OpenAI also provides a project-only memory option for supported Projects, which keeps the context focused on that Project.
5. Move Existing Conversations Into a Project
Sometimes you start a conversation before creating a Project.
If the conversation is relevant to your Project, ChatGPT may allow you to move it into the Project.
For example, you might have previously discussed:
How should an AI Agent use a vector database?
Later, you create an AI Agent Development Project.
You can move the conversation into the Project so that your previous work becomes part of the Project’s organized workspace.
The exact interface for moving conversations can change as ChatGPT is updated.
6. Use Projects for Long-Term Development
Projects become especially useful when a task takes days, weeks, or even months.
For example, imagine that you are building a Customer Support AI Agent.
During the first week, you work on:
Requirements
During the second week:
Architecture
During the third week:
Database and APIs
During the fourth week:
Tools and RAG
During the fifth week:
Testing
Instead of creating unrelated conversations, you can keep all of these discussions inside the same Project.
This creates a much more organized development environment.
7. Use Different Conversations for Different Problems
It is tempting to put everything into one very long conversation.
For a large project, this isn’t always the best approach.
Instead, create separate conversations for major subjects.
For example:
AI Agent Development
- Requirements
- Architecture
- Database
- LLM
- Prompting
- Tools
- Memory
- RAG
- Security
- Testing
- Deployment
This makes it easier to find previous discussions later.
8. Ask ChatGPT to Summarize Your Work
When a Project becomes large, it can be useful to periodically ask ChatGPT to create a summary.
For example:
Summarize the current state of our AI Agent project, including completed work, important decisions, unresolved issues, and next steps.
The result can become a useful project status document.
You can then save the summary as a document and add it back to the Project if appropriate.
9. Use Projects for Learning
Projects are not only useful for professional software development.
They can also be used as a personal learning environment.
For example, create a Project called:
AI Agent Learning
Then use it to study:
- AI Agent architecture
- LLMs
- Prompt engineering
- Tool calling
- Memory
- RAG
- MCP
- Multi-Agent systems
- AI Agent frameworks
You can ask ChatGPT to act as your teacher and create exercises and explanations based on your level.
10. Use Projects for Software Development
Projects can also be used to organize a software development project.
For example:
Customer Management System
You could keep:
- Requirements
- Architecture
- Database design
- API documentation
- Programming discussions
- Testing strategy
- Technical decisions
inside the same Project.
However, remember that a ChatGPT Project is not a replacement for Git, source-code management, issue tracking, or proper project management systems.
For professional software development, you should still use appropriate development and version-control tools.
11. Projects and Codex
Projects and Codex serve different purposes.
Projects provide an organized workspace for conversations, files, instructions, and project context.
Codex is a specialized AI coding agent designed to work with software development tasks.
You might therefore use both.
For example:
ChatGPT Project
Plan the architecture of the application.
Codex
Implement the authentication service in the existing repository.
This combination can be very useful for software developers.
12. Projects Are Not AI Agents
This distinction is important.
A Project is a workspace.
An AI Agent is a system that can pursue a goal, reason about tasks, use tools, and perform actions within defined permissions.
Therefore:
Project ≠ AI Agent
A Project can help you organize the development of an AI Agent, but creating a Project does not automatically create an AI Agent.
For example:
Project
AI Customer Support Agent
Inside it you might have:
Requirements → Architecture → Tools → Memory → RAG → Testing
Eventually, you could use the knowledge and designs developed in the Project to build an actual AI Agent.
A Practical Example
Let’s continue with our AI Agent Development Project.
Imagine that we have already added:
Project Instructions
Act as a senior AI Agent architect and .NET developer.
Files
Customer requirements
Product documentation
API documentation
Conversations
Requirements
Architecture
Tools
Now we can start a new conversation:
User:
Based on our requirements and architecture, design the tools that our AI Agent needs.
ChatGPT can help us develop the design.
We can then ask:
Which tools should require user approval before execution?
Then:
Design the API for these tools.
Then:
Create a security strategy for tool execution.
The Project becomes a central place where we develop the idea step by step.
Best Practices for Using Projects
Here are some simple recommendations:
1. Give Projects clear names
Use:
AI Customer Support Agent
instead of:
Project 1
2. Write useful Project instructions
Tell ChatGPT what role it should play and what technologies you are using.
3. Keep related work together
Don’t mix completely unrelated subjects in the same Project.
4. Organize large projects into separate conversations
Create a conversation for each major subject.
5. Keep important documents available
Add relevant requirements and documentation to the Project.
6. Review AI-generated information
ChatGPT can make mistakes. Important technical decisions should always be verified.
7. Protect sensitive information
Do not unnecessarily upload passwords, private keys, API keys, or confidential information.
What Have We Learned?
In this tutorial, we learned how to use ChatGPT Projects effectively.
We learned that Projects can help us:
- Organize conversations
- Store reference files
- Define Project instructions
- Maintain context
- Separate different areas of work
- Support long-running projects
- Learn new technologies
- Plan and develop AI Agents
Most importantly, we learned that a Project is a workspace, not an AI Agent.
Projects can help us organize our work while tools such as Codex can help us perform software-development tasks.
Conclusion
Projects provide an organized environment for working with ChatGPT over a long period of time.
For AI Agent development, they can be particularly useful because an Agent project may involve many different subjects, including architecture, programming, tools, memory, RAG, security, testing, and deployment.
By organizing these discussions, documents, and instructions inside one Project, we can build our AI Agent knowledge and development process step by step.
In the next post, we will explore Memory and learn how memory allows AI systems to retain and use information across interactions.