➡️ 🌍📱👉COPY & PASTE LINK👉👉👉 https://up-community.wiki/ds/ Wondershare Filmora 14.3.2 Crack is an excellent software for video editing. It is beneficial in perfect video editing with industry standards.

1. 1
AI-Driven Development
Mar, 2025
Created by Shafik Amin, Presented by: Shereef Marzouk

2. 2
Outline
● Core concepts
● History
● Today
● Strengths / Weaknesses of AI
● GitHub Copilot
● Discussion and Q&A
● Live Demo
● Prompt Best Practices
● Discussion and Q&A

3. 3
Core Concepts
● Artificial Intelligence: A very broad field in computer science
that was founded in 1956 which attempts to simulate human-
like intelligence in computers.
● LLM: A specific type of neural-network based AI model trained
on a vast amount of text data.
● Transformer Architecture: The neural-network architecture
used at the heart of LLMs, popularized by the landmark Google
2017 paper “Attention is all you need”.
● AI Agents: Software powered by LLMs that can interact with
digital environments, make decisions, and execute actions
autonomously.
● Hallucination: When an LLM generates plausible-sounding but
incorrect outputs.

4. 4
History
● Computers have been assisting programmers with writing code since
the very beginning.
● It’s a story of ever-increasing abstraction and automation, freeing up
the programmer to spend more time solving higher-level problems, at
the cost of relinquishing control over the finer details.
● In the 1940s, programs were written directly in machine-code (binary
or hex)! The introduction of assemblers in the 1950s greatly improved
the “developer experience”.
● In the 1970s, IDEs were introduced which further improved
programming and made it less error-prone. Auto-complete was an
important feature.
● In the 2020s, LLM vendors quickly realized that code is something very
natural for LLMs to generate for 2 main reasons: code is “text-only” and
there was a huge amount of code publicly available for training.

5. 5
History
Era Key Developments Impact
1940s–1950s Machine Code & Assembly Language Programmers wrote in binary or symbolic machine
code. Extremely low-level and error-prone.
1950s–1960s High-Level Languages (Fortran, COBOL, ALGOL) Introduced human-readable syntax, enabling focus
on logic and algorithms.
1950s–1960s Compilers & Interpreters Automated translation of high-level code to machine
code, speeding up development.
1960s–1970s Structured Programming & Modular Design (Pascal, C) Encouraged cleaner, reusable, and maintainable
code through functions and libraries.
1970s–1980s Integrated Development Environments (IDEs) Combined code editors, debuggers, and compilers
into a single interface.
1980s–1990s Object-Oriented Programming (C++, Java, Python) Introduced classes, objects, and inheritance for
modeling real-world entities.
1990s–2000s Open Source & Libraries (Linux, Apache, NumPy, jQuery) Enabled collaborative development and reuse of
pre-built functionality.
2000s Version Control & Collaboration Tools (Git, GitHub) Allowed teams to track changes, collaborate, and
manage codebases effectively.
2010s Modern Developer Tools (VS Code, npm, pip, Cloud Platforms) Advanced features like IntelliSense, package
management, and cloud deployment.
2020s AI-Assisted Programming (GitHub Copilot, ChatGPT, LLMs) AI tools suggest code, generate functions, and assist
with debugging and documentation.

6. 6
Today
LLM-based agents have
become incredibly good at
code generation.
Coding benchmarks like
HumanEval, MBPP,
CodeEditorBench, RobustAPI,
Arena-Hard, and others
suggest that LLMs have
already surpassed humans
in code-generation
capabilities.

7. 7
Why are LLMs so good?
"Merely predicting the next token" is an oversimplification of the
Transformer architecture. Instead think of compressing the world's
knowledge into billions of neural-network weights. This creates a
deep model of reality.
LLMs are now much more than just a Transformer network:
advanced techniques are employed like Function-Calling, RAG,
Chain-Of-Thought, Mixture-Of-Experts, etc.
Massive Scale: Billions (or even Trillions?) of parameters/weights,
with mega-compute clusters for training and inference.
RLHF: Reinforcement Learning from Human Feedback.
All of this results in incredible emergent intelligence.

8. 8
AI-powered coding assistants
There are now many different AI coding assistants to choose from,
usually in the form of IDE plugins:
• ChatGPT (especially newer models like o1-pro and o3-mini),
Claude 3.7 Sonnet, Gemini, DeepSeek, etc.
• Github Copilot
• Cody (by Sourcegraph)
• Cline (opensource coding Agent)
• Phind (search engine)
• Cursor (vscode fork)
• Tabnine
• Windsurf / Codeium
• Amazon Code Whisperer
• And many more: Lovable, v0, Replit, Devin, Softgen, ...

9. 9
Strengths
• Code Completion: “autocomplete on steroids”.
• Function Generation:
o Especially "pure functions" that are side-effect free. The larger the context required, the
worse the quality of output.
• Test Creation:
o Especially tests for pure functions and side-effect free code.
• Documentation Creation:
o Generate API documentation, docstrings, READMEs, and more.
• Boilerplate Code:
o Expand your definition of "boilerplate": AI is very good at generating things like project-
scaffolding, class-skeletons, for loops, API calls, etc.
• Debugging / Code Review:
o It can detect errors and bugs that are hard to spot by humans.
o Understanding existing code:
o It's easier to write code than to read it. AI can help clarify what a code snippet does,
especially when its context is local and not tied to many external dependencies.

10. 10
Weaknesses
• Hallucinations: Output that seemscorrect but is incorrect or
nonsensical.
• Complex Architectural Decisions: especially when it comes to business-
related trade-offs.
• Understanding ambiguous requirements: and fitting them into the
specific business context.
• Ethical and Legal Considerations: Violating licensing or intellectual-
property laws.
• Security: Generating code with potential vulnerabilities (e.g. SQL
injection/etc).
• Visual Reasoning: generating visually-correct CSS, analyzing complex
images, generating advanced animations, etc.

11. 11
Key Take-Aways
Modern AI coding assistants are a new tool for vastly
improving your productivity but use them with CAUTION.
The more localized the context, the better the output.
There’s no escaping it - if you opt out of AI, you’ll lose
efficiency relative to other developers and team members
who use it effectively.
”English is the hottest new programming language” -Andrej
Karpathy

12. 12
Github Copilot
One of many AI coding assistants, designed to help you write and
generate code in many different scenarios.
Primarily available for VS Code, but there are plugins for other IDEs
as well (JetBrains, etc).
DaySmart will pay your monthly subscription!
Join the #copilot channel and submit a request
OR
Contact Shafik / Matt Pegler / Jason Kirk for access.
Make sure to include your github handle.

13. 13
GitHub Copilot
Multiple features:
• Chat
• Copilot Edits
• Inline Chat/Edit
• Code Completion (press tab to accept)
• Source control: generate commit message
• Voice mode for the above (“vibe coding”)
• Copilot Menu (in multiple places)
• Coming soon: Agent Mode, similar to Cursor Composer
or Windsurf Cascade (executes commands).
• Coming soon: Copilot Pull-Request Review.
• Coming soonish: Autonomous SWE
Project Padawan

14. 14
Discussion and Q&A

15. 15
Live Demo

16. 16
GitHub Copilot - Chat
Participants
Attach
context / files.
Voice mode
Model picker

17. 17
GitHub Copilot - Edits
Agent Mode
(coming soon)
Agent/Edit

18. 18
GitHub Copilot - Edits

19. 19
GitHub Copilot – Inline Chat/Edit

20. 20
GitHub Copilot – Code Completion

21. 21
GitHub Copilot – Commit Messages
Generate Commit Message

22. 22
GitHub Copilot – Menu

23. 23
Prompt Best Practices - Code Generation
Be concise and specific about the task (what the code should do) and
include details like the language, function/class name if applicable, and
any requirements (algorithms, libraries, edge cases). If you expect a
certain style or format (comments, docstring, etc.), say so.
Good Prompt: "Writea Python function factorial(n) that calculatesa number’s
factorial. It should use recursion and handle the case of negative inputs by
returning an error message.”
This prompt clearly specifies the language (Python), the function name
and purpose (calculate factorial), and includes requirements (use
recursion, handle negative input). Such specific instructions help the AI
“hit the bullseye” in terms of what code to produce.
Bad Prompt: “Createa function to look for lines of code that are seenmultiple
times throughout the file and delete them.”
This can confuse the AI. Instead try “createafunction that eliminates duplicate
lines in a text file”.

24. 24
Prompt Best Practices - Debugging
Provide the context of the problem, including the code (or the relevant
snippet) and a description of the error or unexpected behavior. If there’s
an error message, include it. Asking the assistant to both find the root
cause and suggest a fix can be very effective.
Good Prompt: "I have a bug in the following function; it’s supposed to parse
JSON but is throwing an Unexpected token error. Identify the bug and fix it and
explain what was wrong.
Bad Prompt: ”This code is broken. How do I fix it?"

25. 25
Prompt Best Practices - Refactoring
Frame your prompt to include the goals of refactoring (e.g. improve
efficiency, readability, adhere to style guidelines. It’s important to mention
that functionality should remain unchanged.
Good Prompt: "Refactor this to improve its readability and efficiency without
changing its functionality. Use best practicesandadd comments.”
Bad Prompt: ”Make this code better.”

26. 26
Prompt Best Practices – Code Explanation
Context is everything. Tell the AI what code or concept needs explaining,
and specify the depth of explanation or format. E.g. ask for a plain-English
summary, a line-by-line explanation, or a docstring/comment for the
code.
Indicate the audience if relevant (e.g. “for a beginner” vs. “for experienced
developers”).
Good Prompt: "Explain this code step by step, in simple terms, and
describe what it does to a beginner audience.”
Bad Prompt: “What does this do?”

27. 27
Prompt Best Practices – Writing Tests
Specify the scope of testing, the framework or language, and either
provide the code to test or describe the functionality in detail. Indicate
whether you want unit tests, integration tests, or even edge-case
scenarios, and mention any specific libraries (like PyTest, JUnit, etc.) it
should use so that the format is correct.
Good Prompt: "Write unit tests for this function using PyTest. Include tests
for typical cases (e.g., 5 or 10), edge cases like 0 or negative input, and
verify that it raises an error for invalid inputs.”
Bad Prompt: “Test this code.”

28. 28
GitHub Copilot – PR Review (coming soon)
Select Copilot as Reviewer

29. 29
Resources
• Perplexity AI (modern search)
• Youtube:
o Fireship
▪ https://www.youtube.com/c/Fireship
o Visual Studio Code channel:
▪ https://www.youtube.com/@code/videos
• Copilot itself:
o Ask the "@vscode" participant.
o Doesn't work very well yet ...

30. 30
Discussion and Q&A