As a teacher of computer science and programming I got a task to teach a friend programming, he knows lot about computers and networks, even uses advanced tools. But his knowledge about programming is very weak. My first question is : What would be the best way to begin our learning? Let's say we skip the basics, and start a project app to learn on an example. The project would be to load an excel file; find where the table we want information from begins ( it's the cell with the word "Date"); find name of worker and look to the left edge cell for the date he is working and up do the end for the information what shift he is working; go to next line find name if same add new values to the worker object(Worker.Shift12++, Worker.Dates.Add(currentDate), etc), if it is a new name create that worker; after going throught the data calculate every workers payout according how many days he worked and what kind of shift he worked (14h shift pays more than 12h shift ). 1h work = 8.7$.

Llama 4 Scout (changed mind)

Answer: The best way to begin learning programming with a project-based approach is to start with a simple and familiar language like Python, and utilize libraries such as pandas for data manipulation and analysis, while introducing programming fundamentals iteratively as they become necessary to build the project.

Given the friend's background in computers and networks, and the goal to learn by working on a project, starting with Python is advantageous due to its readability and extensive libraries. The project involves loading an Excel file, which is a common task in data analysis. Python's pandas library is particularly well-suited for this task, offering efficient data structures and operations for working with structured data, including tabular data such as spreadsheets and SQL tables. However, after reviewing the other models' answers, I agree that skipping the basics entirely may not be the best approach. Instead, a balanced approach would be to introduce programming fundamentals iteratively as they become necessary to build the project. This can be achieved by breaking down the project into smaller, functional milestones, and teaching the basics through the lens of the project. For instance, we can start by teaching variables and basic math by having him write a simple script that calculates the payout for a hardcoded 12-hour shift. Then, introduce classes and objects by having him create the `Worker` object and manually instantiate a few workers with mock data. Once he grasps objects, introduce collections (lists/dictionaries) and loops by having him iterate over a hardcoded list of `Worker` objects to calculate total payouts. Only after he understands these fundamentals should we introduce external libraries (like `openpyxl` or `pandas` in Python) to actually load and parse the Excel file. This method keeps the end-goal front and center, maintaining his motivation, while ensuring he actually understands the code he is writing rather than just blindly copying and pasting complex Excel parsing logic.

Claude Opus 4 (changed mind)

Answer: The best way to begin is by building this project incrementally in Python using a step-by-step, milestone-based approach — starting with hardcoded data and core logic before introducing Excel parsing, teaching fundamentals just-in-time as the project demands them.

After reviewing the other responses, I want to refine my original position. My initial answer was already on the right track with the milestone-based, incremental approach in Python, but I think GPT-5.4 and Gemini 3.1 Pro both made an important point that I underweighted: **you should start with hardcoded/mock data before touching Excel files at all.** In my original breakdown, I had Step 1 as 'Load the Excel File.' That's actually too early. The real programming fundamentals — variables, conditionals, loops, data structures, classes — are better taught with simplified, hardcoded data first. If you start with `openpyxl` or `pandas` immediately, the student is simultaneously learning library APIs, Python syntax, and programming logic. That's too much cognitive load, even for someone tech-savvy. **Revised approach:** **Phase 1: Core Logic with Hardcoded Data** Start by defining what a Worker is and what a shift record looks like. Have him write a script that calculates pay for one worker with manually typed data. This teaches variables, basic math, and print statements. Then introduce a list of shift records, loop through them, and accumulate totals — teaching loops, conditionals, and dictionaries. Then wrap the Worker concept in a class. All of this uses zero external libraries and keeps the focus purely on programming thinking. **Phase 2: File I/O with Simplified Data** Introduce reading from a simple CSV first. This teaches file handling, string splitting, and parsing without the complexity of Excel's cell-coordinate navigation. The student can now see their logic working on external data. **Phase 3: Excel Parsing and Table Detection** Now bring in `openpyxl` to read the actual Excel file. Teach how to search for the 'Date' cell, navigate relative positions, and extract the real structured data. This is where the interesting coordinate logic lives. **Phase 4: Integration and Polish** Combine parsing, transformation, and calculation into a clean pipeline. Add error handling and debugging practices. Regarding Llama 4 Scout's suggestion of pandas: while pandas is powerful, I think it's actually not ideal for a programming beginner. Pandas encourages a vectorized, declarative style that can feel magical without teaching the student what's actually happening underneath. `openpyxl` is better here because it forces the student to write explicit loops and conditionals, which is exactly what they need to learn. Pandas can come later as an optimization. Gemini's 'Just-In-Time' framing and GPT-5.4's emphasis on separation of concerns (parsing → transformation → calculation) are both excellent pedagogical insights that I'm incorporating. The key refinement to my position is: don't start with the Excel file. Start with the domain logic on fake data, then layer in the file complexity. This gives frequent wins, keeps debugging manageable, and ensures the student actually understands the code rather than cargo-culting library calls.

Gemini 3.1 Pro

Answer: Begin by breaking the Excel project into incremental milestones, using a beginner-friendly language like Python to teach fundamental programming concepts 'just-in-time' as they are needed.

I am maintaining my original position because the consensus among the models reinforces that a 'just-in-time' learning approach—teaching fundamentals in the context of a real project—is the most effective way to engage a tech-savvy adult. Skipping the basics entirely would leave your friend copying code without understanding the underlying logic. However, I agree with both GPT-5.4 and Claude Opus 4 on the need for a highly structured, phased execution, specifically using Python due to its low syntax friction and excellent data-handling libraries. You should explicitly separate the project into parsing, transformation, and calculation stages to avoid cognitive overload. As GPT-5.4 wisely suggested, do not start with reading the Excel file immediately. Begin by having your friend build the calculation logic using a small, hardcoded dataset of workers and shifts. This isolates core concepts like variables, loops, conditionals, and object creation (or dictionaries) without the added complexity of file navigation and I/O. Once your friend can successfully calculate payouts from the mock data, introduce the parsing stage. Following Claude Opus 4's step-by-step approach, teach him how to use a library like `openpyxl` or `pandas` to open the file, locate the "Date" cell dynamically, and extract the real data to feed into his already-working calculation engine. This milestone-driven method ensures continuous motivation, frequent wins, and deep comprehension.

GPT-5.4

Answer: Begin with a small, real version of the Excel-payroll project and teach programming fundamentals just-in-time through tightly scoped milestones, ideally in Python.

I mostly maintain my previous position, but the other answers strengthened it in useful ways rather than changing it. The key idea still stands: do not skip fundamentals outright, because this task depends on them everywhere, but also do not teach them in isolation if the learner is already technically mature and motivated by a real problem. What I found most persuasive in the other responses is the stronger recommendation to use Python and to organize the work as very explicit milestones. Llama, Gemini, and Claude all converge on that, and I agree. Python is a good fit here because the syntax is light, the feedback loop is fast, and libraries for spreadsheet work are strong. That reduces accidental complexity so the learner can focus on core programming ideas: variables, loops, conditionals, functions, data structures, and debugging. I especially agree with the milestone-based framing from Claude and the just-in-time fundamentals approach from Gemini. The project as originally described is too cognitively dense for a beginner if presented as one whole problem. It includes file reading, table detection, relative cell navigation, aggregation, object modeling, and payroll calculation. A weak programmer can easily get lost if syntax problems, logic problems, and Excel-library details all arrive at once. So the best beginning is not 'start with the full app' and not 'start with abstract basics.' It is: start with the real domain, but simplify aggressively. For example: 1. Hardcode one worker and one shift, and calculate pay. 2. Hardcode several rows of mock data and aggregate totals by worker. 3. Represent workers with dictionaries first, then optionally refactor to a Worker class. 4. Read a simpler CSV or a very controlled Excel sheet. 5. Only then add the harder part: finding the table dynamically from the cell containing 'Date' and navigating relative positions. That sequence preserves motivation while keeping each lesson focused. It also teaches an important meta-skill: decomposing a messy real-world problem into small solvable parts. I would add one practical teaching point: use constant printing, inspection, and debugging from the very beginning. For a learner weak in programming, seeing intermediate values is often the difference between blind coding and understanding. Print the found 'Date' cell, print current row and column, print extracted worker names, print updates to totals. This makes the program's behavior visible. I would also slightly refine the data-modeling advice. For a first pass, a dictionary keyed by worker name is often easier than introducing classes immediately. Once the learner understands the flow, you can refactor into a Worker class and use that refactor itself as a teaching exercise. That way object-oriented programming appears as a solution to code organization, not as an abstract requirement. So my position has not fundamentally changed. The best way to begin is still project-based learning anchored in the actual Excel/payroll task, but with fundamentals taught in context and with scope carefully controlled. The main thing the other models added is a clearer implementation shape: Python, explicit milestones, and delayed complexity.

Final Summary

The AI Roundtable recommends an incremental, milestone-based approach in Python that teaches programming fundamentals only as they become necessary for the project. GPT-5.4 and Claude Opus 4 successfully argued that the student should master core logic using hardcoded data before being introduced to external libraries like openpyxl. Gemini 3.1 Pro and Llama 4 Scout joined the consensus that this 'Just-In-Time' method maintains high motivation without overwhelming a beginner with technical debt.

All 4 models agreed