- Project Overview
- Project Scope and Objectives
- User Stories
- Wireframes
- UX Design
- Version Control Practices
- AI Tool Usage
- Code Quality and Standards
- Functional Implementation
- User Experience Quality
- Final Project Submission
- Retrospective
- Plagiarism Guidelines for Learners
- Plagiarism Guidelines Summary
Provide a brief overview of your project, including its purpose and key features.
Define the scope and main objectives of your project. What are you aiming to achieve?
Document detailed user stories with clear priorities and acceptance criteria.
Examples:
- Do: "As a user, I want a homepage with a welcome message, an overview of services/products, and featured content."
- Acceptance Criteria: "Homepage should include a header with a welcome message, a section for services/products with icons, and dynamically updated content."
Create detailed wireframes for each page of your web application. Include notes on layout, navigation, and accessibility features.
Document your UX design decisions. Explain how you have considered user interaction, navigation, and accessibility in your design.
Describe your version control setup and practices. Include information about your commit messages.
Examples:
- Do: Regular commits with descriptive messages documenting key stages of development.
Provide a detailed plan for using AI tools like GitHub Copilot and DALL-E. Specify which parts of the project will use AI-generated code and how you will ensure the quality and originality of this code.
Examples:
- Do: "Use GitHub Copilot for generating user stories, HTML structure, and CSS enhancements. Use DALL-E for creating images."
Describe how you ensured high code quality and adherence to HTML5/CSS3 standards. Include examples of your coding practices.
Examples:
- Do: Well-structured code with consistent indentation, descriptive names, and valid HTML/CSS.
Detail how you implemented the functional elements of your web application. Ensure your implementation meets all user stories' acceptance criteria.
Examples:
- Do: Fully functional homepage with all required sections, interactive elements working smoothly, and excellent UI/UX.
Describe how you ensured a high-quality user experience, focusing on design aesthetics, usability, and responsiveness.
Examples:
- Do: Intuitive and appealing design with smooth navigation and responsive layout.
Provide the link to your deployed web application and ensure your source code repository is well-documented.
Examples:
- Do: Deployed web application with complete source code repository.
Reflect on your development process. Include insights on successes, challenges, and proposed improvements.
Successes:
- Effective Use of AI Tools:
- GitHub Copilot significantly sped up the initial coding process by providing useful HTML and CSS snippets.
- DALL-E generated high-quality images that enhanced the visual appeal of the website.
- Accessibility:
- Implemented ARIA labels and keyboard navigation, making the website accessible to a wider audience.
- Responsive Design:
- The website layout adapted well to different screen sizes, ensuring a good user experience on both desktop and mobile devices.
Challenges:
- Integration of AI-Generated Code:
- Some AI-generated code snippets required significant modification to meet project requirements.
- Ensuring consistency in the design and coding style when integrating AI-generated elements was challenging.
- Time Management:
- Balancing time between coding, testing, and documentation was a learning curve. Initially, too much time was spent on design, which caused a rush during the implementation phase.
Learnings:
- Better Planning:
- Breaking down tasks into smaller, more manageable chunks and setting mini-deadlines helped in better tracking progress.
- Code Reviews:
- Regularly reviewing AI-generated code for quality and consistency is crucial.
- Continuous Testing:
- Frequent testing during the development phase helps in identifying and fixing issues early, reducing last-minute stress.
Proposed Improvements:
- Enhanced AI Tool Usage:
- Explore more advanced features of GitHub Copilot for code optimization.
- Use AI tools for automated testing and validation in future projects.
- Improved Documentation:
- Maintain a more detailed and continuous log of decisions and changes made during the project.
- Time Management:
- Allocate specific time slots for each phase and stick to the schedule more rigorously.
Final Thoughts:
- The project was a valuable learning experience in integrating AI tools with web development.
- The challenges encountered provided significant learning opportunities that will inform future projects.
- Overall, the project outcomes met the initial objectives, and the use of AI tools added efficiency and innovation to the development process.
Guidelines on AI Tool Usage:
- Use Responsibly: While using AI tools like GitHub Copilot, ensure that the code you submit is your own. You should be able to explain all AI-generated content.
- Document Usage: Clearly document where and how AI tools were used in your project, specifying the contributions made by AI versus your own work.
Progress Submissions:
- Intermediate Deliverables: Using this document, submit drafts of your project plan, wireframes, and initial code. These should show the evolution of your project and your understanding at each stage.
Version Control Analysis:
- Regular Commits: Make regular commits to your version control system (e.g., GitHub) to document your progress. Each commit should have a clear message detailing the changes made.
- Detailed Contribution Reports: Include a report explaining your contributions at each stage of the project. Clearly differentiate between AI-generated code and your own work.
Plagiarism Detection:
- Use of Tools: Be aware that plagiarism detection tools will be used to scan your code and documentation for similarities with other sources. Ensure that all content is original or properly cited.
- Original Content: Your project plan and user stories must be your own work. Avoid copying from other sources without proper attribution.
- Specificity and Detail: Ensure that your user stories are specific to your project scenario and not generic templates from the internet.
- Create Your Own Designs: Wireframes and UX design documentation should be original. If you use design tools or templates, customize them significantly to reflect your unique project requirements.
- Accessibility Considerations: Document how you have considered accessibility in your design. This should be based on your understanding and application of accessibility standards.
- Consistent Use: Use your version control system consistently. Regular, descriptive commits will help demonstrate your ongoing work and understanding.
- Branching Strategy: While branching is not required, document any strategies used to manage different parts of your project.
- Clear Usage Plan: Document your plan for using AI tools. Specify which parts of the project will use AI-generated code and how you will ensure the quality and originality of this code.
- Adhere to Standards: Ensure your code meets HTML5/CSS3 standards and follows best practices for readability and maintainability.
- Review and Optimize: Review and optimize AI-generated code. Clearly document any modifications or optimizations you make.
- Document AI Use: Clearly document where AI-generated code is used. Include comments in the code to highlight AI-generated sections.
- Critical Assessment: Critically assess AI-generated code for quality and relevance. Make necessary adjustments to ensure it fits your project requirements.
- Meet Acceptance Criteria: Ensure your implementation meets all user stories' acceptance criteria. Document any challenges and how you addressed them.
- Original Implementation: Avoid copying implementation details from other sources. Your solution should be unique to your project scenario.
- Complete Submission: Ensure your final project submission includes a fully functional web application, source code repository, and deployment link.
- Proper Attribution: If you use any external resources or libraries, provide proper attribution and documentation.
- Reflect Honestly: Your retrospective report should honestly reflect your development process, challenges faced, and lessons learned. It should be your own analysis and not copied from other sources.
- Use AI Tools Responsibly: Ensure you understand and can explain all AI-generated content.
- Document Everything: Clearly document the use of AI tools, progress, and contributions.
- Submit Original Work: Your project plan, user stories, designs, code, and retrospective report must be original and specific to your project.
- Use Version Control: Make regular, descriptive commits to document your progress and contributions.
- Attribute Properly: Properly cite any external resources or libraries used in your project.
By following these guidelines, you can ensure that your work is original, demonstrates your understanding, and adheres to academic integrity standards. Assessors will use these documented processes and tools to verify the originality and authenticity of your work.